{"title":"static Keyword","description":"","content":"So far, almost every field and method you've written has belonged to a specific object. Each `Cart` has its own `items`, each `Customer` has their own `email`. But some data and behavior don't belong to any single object. There's only one running count of how many `Product` instances have ever been created. There's only one `applyTax` helper, and it doesn't need a particular order to do its job. The `static` keyword is how Java lets you put fields and methods on the class itself rather than on every instance.\n\n---\n\n# What `static` Actually Means\n\nA regular (non-`static`) member belongs to each object. Build ten `Product` instances and you get ten copies of every instance field, one per object. A `static` member is different: it belongs to the class itself, and there is exactly one copy of it shared across every instance.\n\nThe class is a kind of container that exists once in memory. Instance fields live inside each object built from the class. Static fields live inside the container, alongside the methods and the class metadata. Every access to the class sees the same shared storage.\n\n\n```mermaid\nflowchart LR\n Class[\"Product class
static productCount = 3
static applyTax()\"]:::orange\n\n P1[\"product1
name = Mouse
price = 29.99\"]:::cyan\n P2[\"product2
name = Cable
price = 9.99\"]:::cyan\n P3[\"product3
name = Headphones
price = 49.99\"]:::cyan\n\n P1 -.belongs to.-> Class\n P2 -.belongs to.-> Class\n P3 -.belongs to.-> Class\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe three `Product` objects each have their own `name` and `price`. The class itself owns `productCount` and `applyTax`. Every object can reach the class-level storage, but there is only ever one copy of it, no matter how many products you build.\n\nThe same idea applies whether you're talking about fields or methods. A `static` field is one shared variable. A `static` method is one function that runs without needing any particular instance.\n\n---\n\n# Static Fields\n\nA static field is declared with the `static` keyword in front of the type. Once declared, it lives in one place and every line of code in the program that mentions it is reading from or writing to the same memory.\n\n\n```java\npublic class Product {\n static int productCount = 0;\n\n String name;\n double price;\n\n public Product(String name, double price) {\n this.name = name;\n this.price = price;\n productCount++;\n }\n\n public static void main(String[] args) {\n new Product(\"Wireless Mouse\", 29.99);\n new Product(\"USB Cable\", 9.99);\n new Product(\"Headphones\", 49.99);\n\n System.out.println(\"Total products created: \" + Product.productCount);\n }\n}\n```\n\n\n`productCount` is one slot. Each constructor reads its current value, adds 1, and writes back. By the time `main` prints, three constructor calls have each bumped that single shared counter, so it reads `3`.\n\nCompare this to the same code with an instance field instead of a static field.\n\n\n```java\npublic class BrokenCounter {\n int productCount = 0;\n\n String name;\n\n public BrokenCounter(String name) {\n this.name = name;\n productCount++;\n }\n\n public static void main(String[] args) {\n BrokenCounter a = new BrokenCounter(\"Wireless Mouse\");\n BrokenCounter b = new BrokenCounter(\"USB Cable\");\n BrokenCounter c = new BrokenCounter(\"Headphones\");\n\n System.out.println(\"a.productCount = \" + a.productCount);\n System.out.println(\"b.productCount = \" + b.productCount);\n System.out.println(\"c.productCount = \" + c.productCount);\n }\n}\n```\n\n\nEvery object got its own counter, and each constructor only bumped that object's copy. The class never had a single shared total. A counter that exists per-object isn't really a counter at all, it's just a yes/no flag for \"did this object's constructor run\".\n\nStatic fields are useful whenever the data conceptually belongs to the class as a whole:\n\n- A counter of how many instances exist.\n- A registry of all objects ever created, so other code can look one up.\n- A shared cache or lookup table.\n- A configuration value like a tax rate that's the same for every order in the system.\n\n\n```java\npublic class Cart {\n static double TAX_RATE = 0.07;\n\n double subtotal;\n\n public Cart(double subtotal) {\n this.subtotal = subtotal;\n }\n\n public double totalWithTax() {\n return subtotal + (subtotal * TAX_RATE);\n }\n\n public static void main(String[] args) {\n Cart cartA = new Cart(100.00);\n Cart cartB = new Cart(250.00);\n\n System.out.println(\"Cart A total: $\" + cartA.totalWithTax());\n System.out.println(\"Cart B total: $\" + cartB.totalWithTax());\n\n Cart.TAX_RATE = 0.09;\n\n System.out.println(\"After rate change:\");\n System.out.println(\"Cart A total: $\" + cartA.totalWithTax());\n System.out.println(\"Cart B total: $\" + cartB.totalWithTax());\n }\n}\n```\n\n\nBoth carts pick up the new `TAX_RATE` the instant it changes, because both reach into the same single slot on the class. There's no per-cart copy to update.\n\nA constant rate like this is exactly the kind of value you'd write as `static final` to lock it in. Here's a one-liner taste so you see the idiom.\n\n\n```java\npublic class TaxedCart {\n static final double TAX_RATE = 0.07;\n\n public static double totalWithTax(double subtotal) {\n return subtotal + (subtotal * TAX_RATE);\n }\n\n public static void main(String[] args) {\n System.out.println(\"Total: $\" + totalWithTax(100.00));\n }\n}\n```\n\n\nThe `final` keyword marks `TAX_RATE` as a one-time assignment. Once set, no code can reassign it, and the compiler enforces that at every call site. The shape (`static final` constant at the top of the class) is common across Java codebases.\n\nA static field is read and written from anywhere in the program, including from multiple threads at the same time. In single-threaded code, this is safe. Once threads enter the picture, shared mutable state on a class becomes a hazard and needs synchronization. Keep mutable static fields rare. Use `static final` constants whenever the value never has to change.\n\n---\n\n# Static Methods\n\nA static method is declared the same way: put `static` in front of the return type. The method belongs to the class, not to an instance. You don't need an object to call it.\n\n\n```java\npublic class CartMath {\n public static double applyTax(double amount, double rate) {\n return amount + (amount * rate);\n }\n\n public static double applyDiscount(double amount, double percentOff) {\n return amount * (1 - percentOff / 100);\n }\n\n public static void main(String[] args) {\n double subtotal = 200.00;\n double afterDiscount = CartMath.applyDiscount(subtotal, 15);\n double afterTax = CartMath.applyTax(afterDiscount, 0.07);\n\n System.out.println(\"Subtotal: $\" + subtotal);\n System.out.println(\"After 15% off: $\" + afterDiscount);\n System.out.println(\"After 7% tax: $\" + afterTax);\n }\n}\n```\n\n\n`applyTax` and `applyDiscount` don't depend on any particular cart or product. They take everything they need as parameters and return a result. That's the classic shape of a static method: pure logic with no per-object state.\n\nLibrary helpers you've already used follow this same pattern:\n\n- `Math.max(a, b)` returns the larger of two numbers without needing a `Math` instance.\n- `Math.round(price)` rounds a value the same way every time.\n- `Integer.parseInt(\"42\")` converts a string into an `int`.\n- `String.valueOf(99.95)` turns any value into its string form.\n\nNone of those require building an object first. The class name plus the method name is the full call.\n\n\n```java\npublic class HelperUsage {\n public static void main(String[] args) {\n int higherCount = Math.max(5, 12);\n double roundedPrice = Math.round(29.95);\n int parsedQuantity = Integer.parseInt(\"7\");\n String priceLabel = String.valueOf(49.99);\n\n System.out.println(\"Higher count: \" + higherCount);\n System.out.println(\"Rounded price: $\" + roundedPrice);\n System.out.println(\"Parsed quantity: \" + parsedQuantity);\n System.out.println(\"Price label: \" + priceLabel);\n }\n}\n```\n\n\nA static method is also the natural home for a **factory method**, a method whose job is to build and return a new object. Factories let you give the construction step a meaningful name and run a little setup logic before handing the object back.\n\n\n```java\npublic class Cart {\n String customerName;\n double subtotal;\n\n private Cart(String customerName, double subtotal) {\n this.customerName = customerName;\n this.subtotal = subtotal;\n }\n\n public static Cart empty(String customerName) {\n return new Cart(customerName, 0.0);\n }\n\n public static Cart withSubtotal(String customerName, double subtotal) {\n return new Cart(customerName, subtotal);\n }\n\n public static void main(String[] args) {\n Cart guestCart = Cart.empty(\"Alice\");\n Cart resumedCart = Cart.withSubtotal(\"Bob\", 149.95);\n\n System.out.println(guestCart.customerName + \": $\" + guestCart.subtotal);\n System.out.println(resumedCart.customerName + \": $\" + resumedCart.subtotal);\n }\n}\n```\n\n\nThe factory names (`empty`, `withSubtotal`) read more clearly at the call site than two unlabeled constructor overloads would. Reading `Cart.empty(\"Alice\")` tells you immediately what kind of cart you're getting.\n\n---\n\n# Calling Static Members\n\nYou can call a static method or read a static field in two ways: through the class name, or through any instance of the class. They both compile, but they aren't equally good.\n\n\n```java\npublic class CallStyles {\n static int productCount = 0;\n\n String name;\n\n public CallStyles(String name) {\n this.name = name;\n productCount++;\n }\n\n public static void resetCount() {\n productCount = 0;\n }\n\n public static void main(String[] args) {\n CallStyles a = new CallStyles(\"Wireless Mouse\");\n CallStyles b = new CallStyles(\"USB Cable\");\n\n System.out.println(\"Via class: \" + CallStyles.productCount);\n System.out.println(\"Via instance: \" + a.productCount);\n System.out.println(\"Via instance: \" + b.productCount);\n\n CallStyles.resetCount();\n System.out.println(\"After reset: \" + CallStyles.productCount);\n }\n}\n```\n\n\nBoth `a.productCount` and `b.productCount` read the same shared slot, so they give the same number. So does `CallStyles.productCount`. But `a.productCount` looks like it's reading something stored inside `a`, which it isn't. The instance variable doesn't actually matter; the compiler resolves the access on the type of `a`, not on the object itself. You can prove that by reading a static field through a `null` reference: the read still works because the object is never touched.\n\nThe convention is firm: **always use `ClassName.member` to access static members**. It makes the static nature obvious at the call site. A reader scanning `CallStyles.productCount` sees the class right there in the expression and knows the field is shared, not per-object. Most IDEs warn when you use the instance form.\n\n\n```java\npublic class WeirdAccess {\n static int productCount = 0;\n\n public static void main(String[] args) {\n WeirdAccess obj = null;\n // The next line works. The compiler reads productCount via the\n // declared type of obj, never dereferences obj itself.\n System.out.println(\"Count: \" + obj.productCount);\n }\n}\n```\n\n\nIf `productCount` were an instance field, that line would throw `NullPointerException`. Because it's static, the access never goes through the reference. That's a quirk, not a feature to use. Always prefer the class-name form.\n\n\n```java\npublic class CleanAccess {\n static int productCount = 0;\n\n public static void main(String[] args) {\n System.out.println(\"Count: \" + CleanAccess.productCount);\n }\n}\n```\n\n\nSame result, but now the code says what it means.\n\n---\n\n# What Static Methods Can and Cannot Do\n\nA static method runs without an instance. There is no `this` available inside it, because no object called the method. That single fact drives every restriction on static methods.\n\nInside a static method, you cannot:\n\n- Use `this`. There is no current object.\n- Read or write an instance field directly. Those fields belong to a specific object, and the static method doesn't know which one.\n- Call an instance method directly. Same reason.\n\nYou can:\n\n- Read and write any static field of the class.\n- Call any other static method of the class.\n- Use any object that's handed to you (as a parameter, a local variable, or a static field).\n\nA class that respects those rules:\n\n\n```java\npublic class InventoryReport {\n static int totalUnits = 0;\n\n int unitsInStock;\n String productName;\n\n public InventoryReport(String productName, int unitsInStock) {\n this.productName = productName;\n this.unitsInStock = unitsInStock;\n totalUnits += unitsInStock;\n }\n\n public static int getTotalUnits() {\n return totalUnits;\n }\n\n public static void printStock(InventoryReport report) {\n System.out.println(report.productName + \": \" + report.unitsInStock + \" in stock\");\n }\n\n public static void main(String[] args) {\n InventoryReport a = new InventoryReport(\"Wireless Mouse\", 20);\n InventoryReport b = new InventoryReport(\"USB Cable\", 35);\n\n printStock(a);\n printStock(b);\n System.out.println(\"Total units across all products: \" + getTotalUnits());\n }\n}\n```\n\n\n`getTotalUnits` reads only the static field, which is fine. `printStock` reads `productName` and `unitsInStock` through the `report` parameter. That works because the method has an explicit object to look at. It would not work if you tried to read `productName` with no object reference, because the method has no implicit \"current\" product.\n\n**What's wrong with this code?**\n\n\n```java\npublic class BrokenReport {\n String productName;\n int unitsInStock;\n\n public BrokenReport(String productName, int unitsInStock) {\n this.productName = productName;\n this.unitsInStock = unitsInStock;\n }\n\n public static void printStock() {\n System.out.println(productName + \": \" + unitsInStock);\n }\n}\n```\n\n\nThe compiler refuses:\n\n\n```shell\nerror: non-static variable productName cannot be referenced from a static context\nerror: non-static variable unitsInStock cannot be referenced from a static context\n```\n\n\n`printStock` is `static`, so no object was passed in. There is no current instance whose `productName` could be read. The fix is to either pass the object explicitly, or make `printStock` an instance method.\n\n**Fix:**\n\n\n```java\npublic class FixedReport {\n String productName;\n int unitsInStock;\n\n public FixedReport(String productName, int unitsInStock) {\n this.productName = productName;\n this.unitsInStock = unitsInStock;\n }\n\n public static void printStock(FixedReport report) {\n System.out.println(report.productName + \": \" + report.unitsInStock);\n }\n\n public static void main(String[] args) {\n FixedReport mouse = new FixedReport(\"Wireless Mouse\", 20);\n FixedReport.printStock(mouse);\n }\n}\n```\n\n\nNow `printStock` has a specific `FixedReport` to look at, passed in as a parameter. The static method's \"no current instance\" rule still holds, but the rule doesn't say a static method can't work with objects at all. It says it can't work with an implicit one.\n\nAnother common version of the same mistake involves `this`.\n\n**What's wrong with this code?**\n\n\n```java\npublic class Greeter {\n String customerName;\n\n public Greeter(String customerName) {\n this.customerName = customerName;\n }\n\n public static void greet() {\n System.out.println(\"Hello, \" + this.customerName);\n }\n}\n```\n\n\nThe error reads:\n\n\n```shell\nerror: non-static variable this cannot be referenced from a static context\n```\n\n\n`this` means \"the object whose method is running\". A static method isn't running on any object, so there's nothing `this` could refer to. The fix follows the same pattern as before.\n\n**Fix:**\n\n\n```java\npublic class Greeter {\n String customerName;\n\n public Greeter(String customerName) {\n this.customerName = customerName;\n }\n\n public static void greet(Greeter greeter) {\n System.out.println(\"Hello, \" + greeter.customerName);\n }\n\n public static void main(String[] args) {\n Greeter alice = new Greeter(\"Alice\");\n Greeter.greet(alice);\n }\n}\n```\n\n\nPass the object in explicitly. If you find yourself doing this often, it's a sign the method probably wants to be an instance method, not a static one.\n\nThere's no rule in the other direction. An **instance method** can read and write static fields, call static methods, and use `this`. Static members are accessible from everywhere, including from inside instance methods.\n\n\n```java\npublic class Order {\n static int orderCount = 0;\n\n int orderId;\n double total;\n\n public Order(double total) {\n orderCount++;\n this.orderId = orderCount;\n this.total = total;\n }\n\n public void printSummary() {\n System.out.println(\"Order #\" + orderId + \" ($\" + total + \"), total orders so far: \" + orderCount);\n }\n\n public static void main(String[] args) {\n new Order(49.99).printSummary();\n new Order(129.50).printSummary();\n new Order(19.95).printSummary();\n }\n}\n```\n\n\n`printSummary` is an instance method, so it can read both instance fields (`orderId`, `total`) and the static field (`orderCount`). The static counter doubles as an auto-incrementing ID generator, a common pattern in early prototypes.\n\n---\n\n# Where Static Fields Live in Memory\n\nA static field is stored once per class, in a region of memory associated with the class itself. Instance fields live inside each object on the heap. Static fields live in class-level storage that the JVM creates when the class is **loaded**.\n\nA class is loaded the first time the program needs it: the first time you create an instance, call a static method, or read a static field. At that moment, the JVM reads the class file, sets aside the class-level storage, and runs the initializers for every static field in source order.\n\n\n```mermaid\nflowchart LR\n Source[\"Source file
Product.java\"]:::cyan --> Load[\"JVM loads Product class
(first time it's needed)\"]:::orange\n Load --> Init[\"Set up class storage
productCount = 0
TAX_RATE = 0.07\"]:::teal\n Init --> Use[\"Class is ready to use
new Product()
Product.productCount\"]:::green\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```\n\n\nThe static area is created once. From there on, every access to a static field on that class reads the same slot, and every static method runs against the same shared state. Instance fields, by contrast, get fresh storage every time you call `new`.\n\nThe deep details of class loading and where exactly the class-level storage lives in the JVM are a topic of their own. The takeaway:\n\n- Static fields are initialized **once**, when the class is loaded.\n- They live for the entire run of the program (unless the class is unloaded, which is rare).\n- All instances see the same shared slot.\n\nFor more elaborate setup than a single initializer expression can handle, for example, populating a static lookup table from a loop, **static initializer blocks** are appropriate. They run at class-load time, in the same step as the field initializers.\n\n---\n\n# When to Use `static`\n\nUse `static` when the field or method belongs to the class as a whole, not to any particular instance.\n\n\n| Use static for | Don't use static for |\n| --- | --- |\n| Utility/helper methods that compute from arguments alone | Methods that need data from a specific object |\n| Counters, registries, caches shared across all instances | Per-object state like `name`, `email`, `cart contents` |\n| Factory methods that build and return objects | Behavior that varies between instances |\n| Constants (`static final` values) | Anything that should be different for each instance |\n\n\nA few concrete e-commerce examples that fit cleanly:\n\n- `Product.productCount` keeps track of how many products have been created.\n- `Cart.applyTax(amount, rate)` computes a tax without needing a cart.\n- `Order.nextOrderId()` returns the next ID from a shared counter.\n- `Cart.empty(customerName)` is a factory that builds an empty cart.\n- `Cart.TAX_RATE` is a shared constant used by every cart.\n\nA few that shouldn't be static:\n\n- `cart.addItem(product)` belongs to a specific cart.\n- `order.markShipped()` belongs to a specific order.\n- `customer.applyLoyaltyDiscount()` depends on this customer's loyalty points.\n\nThe simplest test: would the method ever need different behavior depending on which object called it? If yes, it's an instance method. If the only inputs are the arguments, it's a static method.\n\n\n```java\npublic class OrderIdGenerator {\n static int nextId = 1001;\n\n public static int nextOrderId() {\n return nextId++;\n }\n\n public static void main(String[] args) {\n System.out.println(\"Next: \" + nextOrderId());\n System.out.println(\"Next: \" + nextOrderId());\n System.out.println(\"Next: \" + nextOrderId());\n }\n}\n```\n\n\nThere's only one running ID counter for the whole program, so a static field and a static method are appropriate. Hanging the counter off a specific `OrderIdGenerator` instance would complicate things, since the counter has nothing to do with any one generator.\n\n---\n\n# A Worked Example\n\nA small program that uses static fields and methods alongside instance state. The class tracks how many `Order` objects have been created, generates new IDs from a shared counter, and offers a static helper for computing totals with tax.\n\n\n```java\npublic class Order {\n static int orderCount = 0;\n static final double TAX_RATE = 0.07;\n\n int orderId;\n String customerName;\n double subtotal;\n\n public Order(String customerName, double subtotal) {\n orderCount++;\n this.orderId = orderCount;\n this.customerName = customerName;\n this.subtotal = subtotal;\n }\n\n public static double withTax(double amount) {\n return amount + (amount * TAX_RATE);\n }\n\n public static int howManyOrders() {\n return orderCount;\n }\n\n public void printReceipt() {\n double total = withTax(subtotal);\n System.out.println(\"Order #\" + orderId + \" for \" + customerName);\n System.out.println(\" Subtotal: $\" + subtotal);\n System.out.println(\" Total: $\" + total);\n }\n\n public static void main(String[] args) {\n Order alice = new Order(\"Alice\", 49.99);\n Order bob = new Order(\"Bob\", 129.50);\n Order carol = new Order(\"Carol\", 19.95);\n\n alice.printReceipt();\n bob.printReceipt();\n carol.printReceipt();\n\n System.out.println(\"Total orders placed: \" + Order.howManyOrders());\n System.out.println(\"Tax on $200: $\" + (Order.withTax(200) - 200));\n }\n}\n```\n\n\nThree details:\n\n- `orderCount` and `TAX_RATE` are shared. Each constructor reads and updates the same counter, and every receipt reads the same tax rate.\n- `withTax` is a static helper called from inside an instance method (`printReceipt`). Instance methods can freely call static ones.\n- `howManyOrders` and `withTax` are called through `Order.` from `main`. That makes their static nature visible to anyone reading the code.\n\nPutting `withTax` inside `printReceipt` and calling it without an instance works because both methods live in the same class. The class-name form (`Order.withTax`) is more explicit, especially when reading code from outside the class.","pageType":"java"}

static Keyword

Get Premium