Java Variables: Primitive Types, Type Casting, and String

The Eight Primitive Types

Java has eight primitive types. Each one stores a different kind of basic value. The "when to use" column answers the most common question: "Which int should I use?"

Declaring and Initializing Variables

Java requires you to declare the type before the name. This is the one syntax rule you must follow:

int score;

int score = 0;

int id = 1;
String name = "Widget Pro";
double price = 19.99;

int quantity;
quantity = 5;

int id = 1;
String name = "Widget Pro";
double price = 19.99;
int quantity = 5;

int id = 1, name = "Widget Pro", price = 19.99, quantity = 5;

Notice the pattern: type name = value . The semicolon is required. The type comes first, then the name, then the value. You can declare multiple variables on one line as long as they share the same type.

Variables that are not initialized contain a default value. Using an uninitialized int score; gives it the default value of 0 .

Type Casting

Java is a statically typed language. Every variable has a type, and the compiler checks that the value you assign matches. When it doesn't match, you get a compile-time error. Type casting is how you tell the compiler "trust me, I know what I'm doing."

Why You Need to Cast

The most common reason is reading a number from a text source (user input, configuration file, API response). Text is a String , numbers are String , and they're incompatible. Casting converts between them:

// This line causes a compile error:
String userInput = "42.5";
double price = Double.parseDouble(inputInput);  // OK

// This also causes a compile error:
String userInput = "42.5";
int count = (int) userInput);  // ERROR

The Narrowing Trap

Casting from a larger type to a smaller type can lose data. Java requires an explicit cast to confirm you accept the risk:

int bigNumber = 200;
byte smallNumber = bigNumber;          // ERROR: possible lossy conversion
byte smallNumber = (byte) bigNumber;  // OK — explicit cast

The String Type

String is the one type that breaks the "all types are primitive" rule. It's actually a class (a reference type), not a primitive. But Java gives it special syntax to keep it simple to write:

String name = "Hello";  // This creates a String object

Strings are immutable — once created, the value cannot be changed. You can't do name = name.replace("Hello", "Hi") . This makes Strings safe to use as map keys and return values from methods (you can't accidentally modify them). The immutability guarantee is why == doesn't work for String comparison — two different String objects that contain the same text are still different objects in memory.

// WRONG — compares object identity (are these the same object?)
String a = "Hello";
String b = "Hello";
System.out.println(a == b);  // false — they're different objects

// CORRECT — compares the actual content
String a = "Hello";
String b = "Hello";
System.out.println(a.equals(b));  // true

Variable Scope and the final Keyword

Scope determines where a variable is visible. A variable declared inside a block ({...}) is invisible outside it. A variable declared as a field in a class is visible to all methods in the class. Understanding scope prevents accidental name collisions — two different variables with the same name in different scopes don't interfere with each other.

The Scope Bug: Variable Shadowing

public class ScoreTracker {

    private int totalScore = 0;

    public void addScore(int points) {
        int total = totalScore + points;  // BUG: creates a LOCAL variable
    }
    public int getTotalScore() {
        return totalScore;  // Still 0 — the local variable
    }
}

This bug happens because int totalScore = totalScore + points declares a new local variable that hides the field. The assignment targets the local variable, not the field. Fix it by renaming one of them.

The final Keyword

public static final double TAX_RATE = 0.08;

public class static final double TAX_RATE = 0.08;

public static final String DEFAULT_TAX_RATE = "default";

Summary

• Variables are named storage locations for values in memory, identified by a type. Java requires the type to be declared before the name.
• Java has eight primitive types: byte , short , int , long , float , double , char , boolean . Use int by default — it's the default integer type.
• Type casting converts between types when they don't match. Use (Type) value syntax. Be especially careful with the narrowing trap (large type to smaller type loses data).
String is a class (a reference type), not a primitive. Use .equals() for comparison, not == . It's immutable — you can't modify a String object after creation. final marks a variable as constant. Use it for values that should never change. Don't use it "just in case."

Where to Go After Variables