Java Variables: Declaration, Initialization, Scope, and Different Forms

A variable is a named box that holds a value while your program runs. You give it a type, a name, and then you put data inside it. Reading the value back later is how your program remembers things.

int customerAge = 25;
// type + name + value

The three parts have distinct jobs. The type such as int or String decides what kind of data can go inside and how much memory it needs. The name is what you call it, so it must follow identifier rules. The value is the actual data stored at that moment.

HOW A VARIABLE IS CREATED

    ┌──────────────────────────────────────────────┐
    │   TYPE      int            how much, which  │
    │   NAME      customerAge    how you refer to│
    │   VALUE     25             the real data    │
    └──────────────────────────────────────────────┘

  Change the type later  ──►  not allowed, the box is fixed
  Change the value later ──►  always allowed, that is the point

The idea of a fixed box is what makes Java strongly typed. A box declared as int can hold whole numbers only, and the compiler will stop you before your program runs if you try to store text in it.

The place you declare a variable decides almost everything about it: how long it lives, who can see it, whether it has a default value, and where it is stored in memory.

THE SAME DECLARED IN THREE PLACES public class Order {
    static int orderCount = 0;
    //  static    -> ONE copy, shared
    String customerName;
    //  instance  -> one copy per object
    void place() {
        int quantity = 2;
        //  local     -> lives only in this block
    }
}

A local variable is declared inside a method body, a constructor body, or any block between braces. It is the most common variable you will write and the easiest to reason about, because it simply stops existing when the block ends.

• You must initialize a local variable before you read it, or the compiler refuses to build your program.

• Two local variables with the same name can exist in two different methods, or even two different blocks, without any conflict.

• A local variable is not visible to any other method or class.

• Its scope begins at the declaration line and ends at the closing brace.

public class LocalVariableDemo {
    public static void main(String[] args) {
        int marks = 88;
        // declared and initialized together
        String grade;
        grade = "B";
        // initialized later, still fine
{
            int marks = 50;
            // a NEW variable, this block only
            System.out.println("inner marks = " + marks);
        } System.out.println("outer marks = " + marks + ", grade = " + grade);
    }
}

The inner marks above is a completely separate variable. Java allows it because the inner one is not visible outside its own block, and that is exactly what people mean when they talk about scope.

An instance variable is declared directly inside the class body, outside every method. Each object built from that class gets its own private copy of every instance variable.

• They are created when you use new to build an object, and disappear when that object is no longer referenced.

• You can read or write them through the this keyword to be explicit about which object you mean.

• They do not need to be initialized, because Java assigns a sensible default.

• They are the state of an object, which is why most real Java classes are built around them.

public class Student {
    int rollNumber;
    // no modifier needed to declare a field
    String name;
    double percentage;
    boolean isPassed;
    public void promote() {
        this.percentage = this.percentage + 5;
        // this marks the current object
        if (this.percentage >= 40) {
            this.isPassed = true;
        }
    } public static void main(String[] args) {
        Student first = new Student();
        first.rollNumber = 7;
        first.name = "Tanmoy";
        first.percentage = 38;
        first.promote();
        System.out.println(first.name + " -> " + first.percentage + ", passed = " + first.isPassed);
    }
}

A static variable is declared with the static keyword inside the class body. There is exactly one copy of it, created when the class loads, and every object of that class shares it.

• Use static for state that genuinely belongs to the whole class, such as counters, configuration, and caches.

• Access it through the class name rather than an object, because that is clearer and avoids confusion: ClassName.counter.

• Changing a static value changes it for every object at once.

• Because shared state is harder to test and reason about, use static sparingly.

public class Account {
    private static int nextAccountNumber = 1000;
    // one copy for all accounts
    private final int accountNumber;
    private double balance;
    public Account() {
        accountNumber = ++nextAccountNumber;
        // unique per object
        balance = 0;
    } public int getAccountNumber() {
        return accountNumber;
    } public static void main(String[] args) {
        Account a = new Account();
        Account b = new Account();
        Account c = new Account();
        System.out.println(a.getAccountNumber() + " " + b.getAccountNumber() + " " + c.getAccountNumber());
        // 1001 1002 1003
        System.out.println("counter is now " + Account.nextAccountNumber);
    }
}

Try removing the static keyword from nextAccountNumber and the program stops compiling, because a non-static field cannot be reached from a static context. That single keyword is what turns a field into a shared counter.

Parameters are variables written inside the parentheses of a method or constructor signature. They behave like local variables: they exist only while that method runs, and they are given a value by the caller.

public class Rectangle {
    private double length;
    private double width;
    // Constructor parameters are assigned to fields
    public Rectangle(double length, double width) {
        this.length = length;
        // this.length = field, length = parameter
        this.width = width;
    } // Method parameters are used to compute a result
    public double area(double scaleFactor) {
        return length * width * scaleFactor;
    }
}

Important: Java always passes arguments by value. For an int the value is copied. For an object the reference is copied, which means both variables point at the same object.

static void modify(StringBuilder builder) {
    builder.append("-changed");
    // same object, caller sees the change
}static void reassign(StringBuilder builder) {
    builder = new StringBuilder("-new");
    // only the parameter changes
}

• Mutating an object passed in is visible to the caller.

• Reassigning the parameter inside the method is not, which surprises almost everyone at first.

Java lets you declare and initialize in several slightly different ways, and beginners meet all four quickly.

FOUR COMMON WAYS TO DECLARE AND INITIALIZE A) DECLARE AND INITIALIZE IN ONE STEP int marks = 88;
B) DECLARE FIRST, INITIALIZE LATER int marks;
marks = 88;
C) SEVERAL NAMES OF THE SAME TYPE int x, y, z;
x = 1;
y = 2;
z = 3;
D) FINAL OR INFERRED final int limit = 100;
var price = 249.99;

public class DeclarationForms {
    static final double GST_RATE = 0.18;
    // constant at class level
    int instanceValue = 42;
    // instance with a value
    public int compute(int input, int bonus) {
        int result = input + bonus;
        // local, one step
        int step1, step2;
        // local, two names
        step1 = result * 2;
        step2 = result * 3;
        var shortcut = step1 + step2;
        // var infers int
        return(int)(shortcut *(1 + GST_RATE));
    }
}

• You may declare several variables of one type in a single statement, but only the last one can be initialized inline.

• A final variable must be initialized exactly once, either inline or in the constructor.

• Assigning a different type later is a compile error, even between compatible numeric types. The explicit cast is required.

This is the detail that surprises new Java programmers most. A field can be used without ever being assigned, but a local variable cannot.

public class DefaultValueDemo {
    static int staticNumber;
    int instanceNumber;
    String text;
    int[] numbers;
    public static void main(String[] args) {
        DefaultValueDemo d = new DefaultValueDemo();
        System.out.println("staticNumber  = " + staticNumber);
        // 0
        System.out.println("instanceNumber= " + d.instanceNumber);
        // 0
        System.out.println("text          = " + d.text);
        // null
        System.out.println("numbers[2]    = " + d.numbers[2]);
        // null
        int localNumber;
        // ERROR: must be initialized first
        // localNumber = 5;
    }
}

The reasoning behind this design is sound. A field always belongs to an object that already exists, so filling in a neutral default is safe. A local variable is used immediately after you write it, so the compiler refuses to invent a value you never meant.

Java scopes go from widest to narrowest: class level, then instance level, then block level. When the same name exists in more than one level, the narrowest one wins, and the wider one is said to be shadowed.

SCOPE FROM WIDEST TO NARROWEST

  ┌──────────────────────────────────────────────────┐
  │ CLASS LEVEL      static int value = 1;           │
  │  ┌────────────────────────────────────────────┐  │
  │  │ INSTANCE LEVEL   int value = 2;            │  │
  │  │  ┌──────────────────────────────────────┐   │  │
  │  │  │ BLOCK LEVEL   int value = 3;         │   │  │
  │  │  │  inside here, value is 3              │   │  │
  │  │  └──────────────────────────────────────┘   │  │
  │  │  back in the method, value is 2            │  │
  │  └────────────────────────────────────────────┘  │
  │  this.value reaches the instance variable        │
  └──────────────────────────────────────────────────┘

public class ShadowingDemo {
    static int value = 1;
    // class level
    int value = 2;
    // instance level
    public void show() {
        System.out.println(value);
        // 2, instance wins here
        if (true) {
            int value = 3;
            // block level, shadows both
            System.out.println(value);
            // 3
        } System.out.println(value);
        // 2 again
        System.out.println(ShadowingDemo.value);
        // 1, fully qualified
    }
}

Shadowing is legal but confusing, which is why most style guides advise against naming a local variable the same as a field.

The final keyword means a variable can be assigned exactly once. After that, the compiler rejects any further change, which is how Java expresses immutability.

• A final local variable must be initialized exactly once, at declaration or later in the same block.

• A final parameter cannot be reassigned inside the method.

• A static final field is the standard way to write a constant in Java.

• A final reference does not freeze the object it points at, only the reference itself.

public class Constants {
    static final double GST_RATE = 0.18;
    // a real constant
    static final String DEFAULT_CURRENCY;
    final int invoiceId;
    // blank final, set in constructor
    static {
        DEFAULT_CURRENCY = "INR";
        // static initializer block
    } public Constants(int invoiceId) {
        this.invoiceId = invoiceId;
    } public void tryToChange() {
        // GST_RATE = 0.20;                    // ERROR: final cannot be reassigned
        final int discount = 10;
        // final, so it can never change
        // discount = 20;                     // ERROR: final cannot be reassigned
        // discount = discount - 1;           // ERROR: still a reassignment
        int price = 100;
        // not final, so this is fine
        price = price - 1;
        // a reassignment, and perfectly legal
    }
}

Writing the name of a constant in UPPER_SNAKE_CASE is a convention rather than a rule, but it is followed everywhere in professional Java, and it is what makes constants instantly recognisable while you read.

From Java 10 onwards you can write var instead of a type, and the compiler works out the type from the value you assign on the same line.

• var works only for local variables, never for fields, method return types or parameters.

• The value must be on the same statement, because there is nothing else to infer from.

• The variable is still strongly typed. Once inferred, var behaves exactly like the real type and cannot later change.

• Use it when the type is obvious from the right-hand side. Do not use it when it hides the type from a reader.

import java.util.ArrayList;
public class VarDemo {
    public static void main(String[] args) {
        var count = 10;
        // inferred as int
        var price = 249.99;
        // inferred as double
        var name = "Java";
        // inferred as String
        var marks = new ArrayList();
        // inferred as ArrayList
        System.out.println(count + " " + price + " " + name);
        System.out.println(marks.isEmpty());
        // var total;                     // ERROR: var needs an initializer
        // var total = null;              // ERROR: nothing to infer from
        // var data = {1, 2, 3};          // ERROR: array initializers not allowed
    }
}

Understanding memory is not required to write Java, but it explains why local variables vanish so quickly and why objects behave differently.

MEMORY LAYOUT AT A GLANCE

  ┌─────────────────────────── STACK ────────────────────────────┐
  │  main() frame          addNumbers() frame                     │
  │  ┌────────────────┐     ┌────────────────┐                   │
  │  │ int a = 5      │     │ int sum = 15   │  local variables   │
  │  │ int b = 10     │     │ int limit = 100│  and parameters    │
  │  └────────────────┘     └────────────────┘                   │
  │  lives while the method runs, then disappears                │
  └───────────────────────────────────────────────────────────────┘
              │ references point down
              v
  ┌─────────────────────────── HEAP ─────────────────────────────┐
  │  Account object A        Account object B       static field │
  │  ┌──────────────────┐    ┌──────────────────┐    ┌──────────┐ │
  │  │ accountNumber 7  │    │ accountNumber 8  │    │ nextId 9 │ │
  │  │ balance 500.00   │    │ balance 250.00   │    └──────────┘ │
  │  └──────────────────┘    └──────────────────┘   ONE shared   │
  │  objects survive until nothing references them                │
  └───────────────────────────────────────────────────────────────┘

• Local variables and method parameters live in the stack frame of the calling method, and disappear when the method returns.

• Objects created with new live on the heap, together with their instance variables.

• Static fields hold one value per class, created when the class is first loaded and freed when the class is unloaded.

• This is why passing an object shares its contents, while reassigning a local variable never affects anyone else.

These are the compile-time errors every Java beginner meets at least once.

• A NullPointerException is the one error you will meet at runtime rather than at compile time, and it always means a reference was never given a value.

• Reading an uninitialized array element is also null or 0, because arrays are objects with their own defaults.

• Assigning an int to a long variable fails, even though it feels safe. The correct move is an explicit cast such as long bigger = (long) smallNumber.

Keep this table nearby while you write your first few programs.

With these ten answers memorised, the next topic, Java data types, becomes easy, because you now know where a value is stored and what it defaults to before you even choose its type.