{"title":"Variables & Data Types","description":"","content":"Every program needs a way to remember things: the price of a product, the number of items in a cart, whether an order has shipped. In Java, those pieces of remembered data live in variables, and every variable has a type that decides what kind of value it can hold. This lesson covers the basics of declaring variables, assigning values to them, and the broad shape of Java's type system.\n\n---\n\n# What a Variable Is\n\nA variable is a named slot in memory that holds a value. You give the slot a name, you tell Java what type of value goes in it, and from then on you can read from it or write to it by name.\n\nHere's the smallest useful example:\n\n\n```java\npublic class ProductPrice {\n public static void main(String[] args) {\n int stockCount = 12;\n System.out.println(\"Items in stock: \" + stockCount);\n }\n}\n```\n\n\n`stockCount` is the variable. It has type `int` (an integer), and it currently holds the value `12`. When we use the name `stockCount` later in the program, Java looks up whatever value is in that slot and uses it.\n\nA variable has three things tied together:\n\n- A **name** you choose, like `stockCount` or `cartTotal`.\n- A **type** that fixes the shape of values it can hold, like `int` or `String`.\n- A **value** stored in it right now, which can change over time as the program runs.\n\nOnce you've declared a variable's type, that type is locked in. You can change the value, but you can't change the type.\n\n---\n\n# Declaring and Initializing Variables\n\nThe basic syntax for a variable declaration is:\n\n\n```shell\ntype name;\ntype name = value;\n```\n\n\nThe first form declares a variable without giving it a value yet. The second form declares it and assigns it a value in the same line, which is called initialization.\n\n\n```java\npublic class ProductInfo {\n public static void main(String[] args) {\n int stockCount; // declared, no value yet\n stockCount = 50; // assigned a value\n\n double price = 29.99; // declared and initialized in one step\n String productName = \"Wireless Headphones\";\n\n System.out.println(productName + \" - $\" + price + \" (\" + stockCount + \" in stock)\");\n }\n}\n```\n\n\nThe line `int stockCount;` just reserves the slot. The next line `stockCount = 50;` puts a value into it. The line `double price = 29.99;` does both at once.\n\nYou can declare multiple variables of the same type on one line, separated by commas:\n\n\n```java\npublic class MultiDeclare {\n public static void main(String[] args) {\n int stockCount = 50, reorderLevel = 10, soldToday = 7;\n System.out.println(\"Stock: \" + stockCount + \", Reorder at: \" + reorderLevel + \", Sold today: \" + soldToday);\n }\n}\n```\n\n\nThat's a shortcut, not a different feature. It's the same as writing three separate lines. Most code uses one variable per line because it reads better and makes diffs cleaner when only one of them changes.\n\n---\n\n# Assignment vs Initialization, and Default Values\n\nOne distinction matters here.\n\n- **Initialization** is the first time a variable gets a value, usually at declaration: `int stockCount = 50;`.\n- **Assignment** is any time you put a value into a variable, whether it's the first time or the tenth: `stockCount = 42;`.\n\nSo initialization is one specific kind of assignment. The reason to keep them separate in your head is that Java treats uninitialized local variables strictly.\n\nA **local variable** is a variable declared inside a method (like inside `main`). Java will not let you read a local variable before it has been assigned a value. The compiler refuses to compile code that does this.\n\n**What's wrong with this code?**\n\n\n```java\npublic class UnassignedRead {\n public static void main(String[] args) {\n int cartTotal;\n System.out.println(\"Total: \" + cartTotal);\n }\n}\n```\n\n\nThe compiler rejects it with an error like:\n\n\n```shell\nUnassignedRead.java:4: error: variable cartTotal might not have been initialized\n System.out.println(\"Total: \" + cartTotal);\n ^\n```\n\n\n**Fix:** Give the variable a value before you read it.\n\n\n```java\npublic class UnassignedRead {\n public static void main(String[] args) {\n int cartTotal = 0;\n System.out.println(\"Total: \" + cartTotal);\n }\n}\n```\n\n\nThis rule applies only to local variables. Fields declared inside a class (but outside any method) get **default values** automatically: numeric types start at `0`, `boolean` starts at `false`, and reference types start at `null`. For now, the takeaway is: inside a method, always assign a value before you read.\n\n---\n\n# Java Is Statically Typed\n\nJava is a **statically typed** language. That means the type of every variable is decided at the moment you declare it, and the compiler checks every read and write against that type. You cannot change a variable's type after declaration, and you cannot store a value of one type in a variable of another type without an explicit conversion.\n\n**What's wrong with this code?**\n\n\n```java\npublic class WrongType {\n public static void main(String[] args) {\n int stockCount = 50;\n stockCount = \"fifty\";\n System.out.println(stockCount);\n }\n}\n```\n\n\nThe compiler reports:\n\n\n```shell\nWrongType.java:4: error: incompatible types: String cannot be converted to int\n stockCount = \"fifty\";\n ^\n```\n\n\n**Fix:** Either keep the variable an `int` and assign a number, or declare it as a `String` from the start:\n\n\n```java\npublic class CorrectType {\n public static void main(String[] args) {\n String stockLabel = \"fifty\";\n int stockCount = 50;\n System.out.println(stockLabel + \" = \" + stockCount);\n }\n}\n```\n\n\nThe compiler catches type mistakes before your program ever runs. That trade-off (more rules up front, fewer surprises later) is part of why Java code tends to fail loudly at compile time rather than silently at run time.\n\n---\n\n# Java's Data Types at a Glance\n\nJava's types come in two big buckets: **primitive types** and **reference types**.\n\n\n```mermaid\nflowchart TD\n A[Java Data Types]:::cyan --> B[Primitive Types
8 built-in]:::orange\n A --> C[Reference Types
Objects, Arrays, String]:::teal\n\n B --> B1[Integer
byte, short, int, long]:::green\n B --> B2[Floating-point
float, double]:::green\n B --> B3[Character
char]:::green\n B --> B4[Boolean
boolean]:::green\n\n C --> C1[String]:::red\n C --> C2[Arrays]:::red\n C --> C3[Custom classes]:::red\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe diagram shows the overall shape. Primitives hold a raw value directly, like a number or a single character. Reference types are objects, and variables of those types hold a reference to where the object lives in memory.\n\n### The 8 Primitive Types\n\nJava has exactly 8 primitive types.\n\n\n| Type | Holds | Example literal |\n| --------- | ------------------------------------ | -------------------- |\n| `byte` | Whole numbers, very small range | `byte tier = 1;` |\n| `short` | Whole numbers, small range | `short year = 2025;` |\n| `int` | Whole numbers, common default | `int stock = 500;` |\n| `long` | Whole numbers, very large range | `long views = 9_000_000_000L;` |\n| `float` | Decimals, less precision | `float rating = 4.5f;` |\n| `double` | Decimals, common default | `double price = 29.99;` |\n| `char` | A single character | `char grade = 'A';` |\n| `boolean` | `true` or `false` | `boolean inStock = true;` |\n\n\nFor now, just know there are 8 of them and what each one is for.\n\n### Reference Types\n\nAnything that isn't a primitive is a reference type. The most common ones you'll meet early are:\n\n- **`String`** for text: `String customerName = \"Alex\";`\n- **Arrays** for fixed-size sequences: `int[] dailySales = new int[7];`\n- **Custom classes** you write yourself, or that come from libraries.\n\n\n```java\npublic class CustomerSummary {\n public static void main(String[] args) {\n String customerName = \"Alex\";\n int orderCount = 5;\n double totalSpent = 249.95;\n boolean isPrimeMember = true;\n\n System.out.println(customerName + \" has \" + orderCount + \" orders, totaling $\" + totalSpent);\n System.out.println(\"Prime member: \" + isPrimeMember);\n }\n}\n```\n\n\n`customerName` is a reference to a `String` object. The other three are primitive values stored directly in the variable. From the outside, that distinction is invisible here, but it matters once you start passing variables to methods and comparing them.\n\n---\n\n# A Quick Note on `var`\n\nSince Java 10, you can let the compiler figure out the type of a local variable for you, using the keyword `var`:\n\n\n```java\npublic class VarExample {\n public static void main(String[] args) {\n var stockCount = 50; // compiler infers int\n var price = 29.99; // compiler infers double\n var productName = \"Headphones\"; // compiler infers String\n\n System.out.println(productName + \" - $\" + price + \" (\" + stockCount + \" in stock)\");\n }\n}\n```\n\n\n`var` doesn't make Java dynamically typed. The compiler picks a type at the point of declaration and locks it in, just as if you'd written it out. `var stockCount = 50;` is identical to `int stockCount = 50;` in every way that matters.\n\n`var` is convenient when the type on the right side is long or obvious.\n\n---\n\n# Scope: Where a Variable Is Visible\n\nA variable is only visible inside the **block** it was declared in. A block is anything between a pair of curly braces `{ }`. Once you leave the block, the variable is gone.\n\n\n```java\npublic class ScopeExample {\n public static void main(String[] args) {\n int cartItems = 3;\n\n if (cartItems > 0) {\n int discount = 10;\n System.out.println(\"Discount applied: \" + discount + \"%\");\n }\n\n // discount is not visible here\n System.out.println(\"Items in cart: \" + cartItems);\n }\n}\n```\n\n\n`cartItems` is declared inside `main`, so it's visible everywhere in `main`. `discount` is declared inside the `if` block, so it's only visible inside that block. Trying to use `discount` after the closing brace of the `if` produces a compile error: the compiler doesn't know what `discount` is anymore.\n\nThis is a deliberately light look at scope. Methods, classes, and nested scopes all have their own rules.\n\n---\n\n# Constants with `final`\n\nSometimes you want a variable that gets assigned once and then never changes: a tax rate, a maximum cart size, a fixed shipping fee. Java lets you mark such a variable with the keyword `final`. Once a `final` variable has been assigned, any attempt to change it is a compile error.\n\n\n```java\npublic class TaxCalculator {\n public static void main(String[] args) {\n final double TAX_RATE = 0.08;\n double cartTotal = 50.00;\n\n double tax = cartTotal * TAX_RATE;\n double grandTotal = cartTotal + tax;\n\n System.out.println(\"Cart total: $\" + cartTotal);\n System.out.println(\"Tax: $\" + tax);\n System.out.println(\"Grand total: $\" + grandTotal);\n }\n}\n```\n\n\nIf you later wrote `TAX_RATE = 0.10;`, the compiler would reject it with `cannot assign a value to final variable TAX_RATE`. By convention, constants like this are named in `UPPER_SNAKE_CASE` so they stand out from regular variables.\n\n`final` does more than just make a local variable constant. It applies to fields, method parameters, classes, and methods, each with its own implications. For now, treat `final` as the way you mark a value that shouldn't change.","pageType":"java"}

Variables & Data Types

Get Premium