{"title":"Classes & Objects","description":"","content":"Up to this point, every program in the course has worked with primitives, arrays, and `static` methods. That's fine for small calculations, but real software models things: products, customers, orders, reviews. Java describes what one of those things looks like, and then builds as many of them as needed from that description. The description is a **class**. Each thing built from it is an **object**. This lesson covers what classes and objects are, how to define one, how to create instances, how their fields and methods are accessed, and what happens in memory when two variables point at the same object.\n\n---\n\n# A Class Is a Blueprint\n\nA class is a template that says: \"Anything of this kind has these fields and supports these actions.\" It's a description, not a thing. Writing a `Product` class doesn't bring any products into existence. It only tells Java what a product looks like and what a product can do.\n\nThe class is like a form for an online store's product page. The form has empty boxes for name, price, and stock count. The form itself doesn't sell anything. To list an actual product, copy the form and fill in the boxes. Each filled-in copy is a separate product.\n\nHere's the smallest useful class in this lesson:\n\n\n```java\npublic class Product {\n public String name;\n public double price;\n public int stockCount;\n}\n```\n\n\nThat's the whole declaration. Three pieces:\n\n- `public class Product` introduces a class named `Product`.\n- The three lines inside the braces are **fields**, also called **instance variables**. They are the boxes on the form. Every product built from this class will have its own copy of `name`, `price`, and `stockCount`.\n- There are no methods yet. That's fine. A class can have only fields, only methods, or both.\n\nBy itself, this class doesn't run anything. To use it, another class with a `main` method creates products.\n\n---\n\n# An Object Is an Instance\n\nAn **object** is a concrete thing built from a class. The class is the recipe; the object is the cake. An object comes into existence with the `new` keyword followed by the class name and parentheses.\n\n\n```java\npublic class CreateOneProduct {\n public static void main(String[] args) {\n Product mouse = new Product();\n mouse.name = \"Wireless Mouse\";\n mouse.price = 29.99;\n mouse.stockCount = 12;\n\n System.out.println(\"Name: \" + mouse.name);\n System.out.println(\"Price: $\" + mouse.price);\n System.out.println(\"Stock: \" + mouse.stockCount);\n }\n}\n```\n\n\nTwo things happen in the line `Product mouse = new Product();`. The right side, `new Product()`, asks Java to build a brand new `Product` object. The left side, `Product mouse`, declares a variable of type `Product` that holds a reference to that new object. `mouse.name`, `mouse.price`, and `mouse.stockCount` read and write the object's fields.\n\nThe dot (`.`) reaches into an object. `mouse.name` means: \"the `name` field of the object that `mouse` points to.\"\n\nFor a second product, run `new Product()` again. The two objects don't share anything:\n\n\n```java\npublic class TwoProducts {\n public static void main(String[] args) {\n Product mouse = new Product();\n mouse.name = \"Wireless Mouse\";\n mouse.price = 29.99;\n mouse.stockCount = 12;\n\n Product cable = new Product();\n cable.name = \"USB Cable\";\n cable.price = 9.99;\n cable.stockCount = 100;\n\n System.out.println(mouse.name + \" - $\" + mouse.price);\n System.out.println(cable.name + \" - $\" + cable.price);\n }\n}\n```\n\n\nEach `new Product()` produces an independent object. Setting `cable.name` does nothing to `mouse.name`. They are separate copies of the form, each with their own boxes.\n\n\n> **INFO**\n>\n> The class file (`Product.java`) and the file with `main` can be the same file or different files. As long as they compile together, `new Product()` works. For brevity, several examples in this lesson keep both classes in one file by making `Product` non-`public`. Both styles are fine for learning.\n\n\n---\n\n# Class vs Object: Keep the Distinction Clear\n\nA class is a **type**. An object is a **runtime entity** of that type. The word \"Product\" in `Product mouse = new Product();` shows up twice for different reasons:\n\n- The first `Product` (before `mouse`) is the type of the variable. It tells Java that `mouse` will refer to a `Product`-shaped object.\n- The second `Product()` (after `new`) tells Java which class to build a new object from.\n\nThe class lives in the source code and the compiled `.class` file. It's loaded once when the program runs. Objects come and go as the program executes. Thousands of `Product` objects can be created from the one `Product` class, just as a clothing factory can stitch thousands of identical shirts from one pattern.\n\n\n```mermaid\nflowchart LR\n Class[\"Product class
(blueprint)
name, price, stockCount\"]:::cyan\n Obj1[\"mouse
name = Mouse
price = 29.99
stockCount = 12\"]:::green\n Obj2[\"cable
name = USB Cable
price = 9.99
stockCount = 100\"]:::orange\n Obj3[\"book
name = Notebook
price = 4.50
stockCount = 50\"]:::teal\n\n Class -->|new Product| Obj1\n Class -->|new Product| Obj2\n Class -->|new Product| Obj3\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nOne class, three independent objects. Each object has its own copy of the fields, holding its own values. Adding a fourth product would create another box on the right without changing anything in the blueprint or the existing boxes.\n\nA handy way to read code: `new ClassName()` brings a brand new object into existence and the expression evaluates to a reference to it. Anywhere else a class name appears (like `Product mouse`), it's being used as a type.\n\n---\n\n# Fields: What an Object Holds\n\nThe fields of a class are the values each object stores. They're declared inside the class body, outside any method, with the same syntax as a local variable: a type followed by a name.\n\n\n```java\npublic class Customer {\n public String name;\n public String email;\n public int loyaltyPoints;\n public boolean isActive;\n}\n```\n\n\nEach `Customer` object will carry its own `name`, `email`, `loyaltyPoints`, and `isActive`. The values are stored on the object itself, which is why they're called **instance variables**, one set per instance.\n\nReading or writing a field uses the object reference, a dot, and the field name:\n\n\n```java\npublic class CustomerDemo {\n public static void main(String[] args) {\n Customer alice = new Customer();\n alice.name = \"Alice\";\n alice.email = \"alice@example.com\";\n alice.loyaltyPoints = 150;\n alice.isActive = true;\n\n System.out.println(alice.name + \" has \" + alice.loyaltyPoints + \" points.\");\n System.out.println(\"Active? \" + alice.isActive);\n }\n}\n```\n\n\nFields are marked `public` for now so they can be read and written directly from outside the class. That's the simplest setup for learning, but it's also the most permissive. The Access Modifiers lesson covers `private`, `protected`, and package-private fields, and the Getters & Setters lesson covers the standard pattern of guarding field access with methods. For this chapter, `public` keeps the focus on what classes and objects actually are.\n\n### Default Field Values\n\nCreating an object with `new` doesn't leave fields uninitialized. Every field gets a well-defined default based on its type, before any user code runs.\n\n\n| Field type | Default value |\n| --- | --- |\n| `byte`, `short`, `int`, `long` | `0` |\n| `float`, `double` | `0.0` |\n| `char` | `'\\u0000'` (the null character) |\n| `boolean` | `false` |\n| Any reference type (`String`, `Product`, arrays, etc.) | `null` |\n\n\nThis applies only to fields, not to local variables inside methods. Local variables have no default and must be assigned before they're read.\n\n\n```java\npublic class DefaultFields {\n public static void main(String[] args) {\n Product blank = new Product();\n System.out.println(\"name: \" + blank.name);\n System.out.println(\"price: \" + blank.price);\n System.out.println(\"stock: \" + blank.stockCount);\n }\n}\n```\n\n\nNo fields were assigned on `blank`, but reading them is legal and returns the defaults. `name` is `null` because `String` is a reference type. `price` is `0.0` because `double` defaults to `0.0`. `stockCount` is `0` because `int` defaults to `0`.\n\nThe defaults are convenient, but they're rarely the values a product or customer should have. A real `Product` with `name = null` and `price = 0.0` isn't a meaningful product. The next lesson covers constructors, which require the caller to provide sensible values when creating an object so blank instances don't end up floating around.\n\n---\n\n# Methods: What an Object Can Do\n\nFields describe what an object knows. Methods describe what an object can do. A method declared inside a class without `static` is an **instance method**, and it operates on whichever object it's called on.\n\n\n```java\npublic class Product {\n public String name;\n public double price;\n public int stockCount;\n\n public void printSummary() {\n System.out.println(name + \" - $\" + price + \" (\" + stockCount + \" in stock)\");\n }\n\n public double totalValue() {\n return price * stockCount;\n }\n}\n```\n\n\nTwo new things here. `printSummary` is a method that prints a one-line description. `totalValue` returns the dollar value sitting in stock for that product. Both methods refer to `name`, `price`, and `stockCount` without an object name in front. Inside an instance method, those names refer to the fields of whichever object the method was called on.\n\n\n```java\npublic class ProductMethodsDemo {\n public static void main(String[] args) {\n Product mouse = new Product();\n mouse.name = \"Wireless Mouse\";\n mouse.price = 29.99;\n mouse.stockCount = 12;\n\n Product cable = new Product();\n cable.name = \"USB Cable\";\n cable.price = 9.99;\n cable.stockCount = 100;\n\n mouse.printSummary();\n cable.printSummary();\n\n System.out.println(\"Mouse inventory value: $\" + mouse.totalValue());\n System.out.println(\"Cable inventory value: $\" + cable.totalValue());\n }\n}\n```\n\n\n`mouse.printSummary()` and `cable.printSummary()` call the same method declaration, but they print different lines because they operate on different objects. When the body of `printSummary` mentions `name`, it picks up the `name` field of the object on which the method was called. Java carries the \"current object\" along internally. The `this` keyword (covered in a later lesson) is the explicit name for that current object, but it's optional for accessing fields and methods.\n\nInstance methods are called the same way as field access: an object reference, a dot, then the method name and its arguments. `mouse.printSummary()` means \"call `printSummary` on the `mouse` object.\"\n\n---\n\n# Multiple Objects, Independent Fields\n\nEvery object created from a class gets its own copy of the fields. Two objects can have the same class but completely different field values, and changing one doesn't affect the other.\n\n\n```java\npublic class IndependentFields {\n public static void main(String[] args) {\n Product first = new Product();\n first.name = \"Headphones\";\n first.price = 49.99;\n first.stockCount = 5;\n\n Product second = new Product();\n second.name = \"Keyboard\";\n second.price = 79.99;\n second.stockCount = 8;\n\n first.stockCount = first.stockCount - 1;\n\n System.out.println(\"First: \" + first.name + \" stock=\" + first.stockCount);\n System.out.println(\"Second: \" + second.name + \" stock=\" + second.stockCount);\n }\n}\n```\n\n\nSubtracting one from `first.stockCount` only changes the `Headphones` object. `second.stockCount` stays at `8` because it lives in a different object. This is what \"each instance has its own state\" means.\n\nA small loop shows how many independent objects fall out of one class:\n\n\n```java\npublic class ThreeProducts {\n public static void main(String[] args) {\n Product[] catalog = new Product[3];\n\n catalog[0] = new Product();\n catalog[0].name = \"Mouse\";\n catalog[0].price = 29.99;\n catalog[0].stockCount = 12;\n\n catalog[1] = new Product();\n catalog[1].name = \"Cable\";\n catalog[1].price = 9.99;\n catalog[1].stockCount = 100;\n\n catalog[2] = new Product();\n catalog[2].name = \"Notebook\";\n catalog[2].price = 4.50;\n catalog[2].stockCount = 50;\n\n for (int i = 0; i < catalog.length; i++) {\n System.out.println(catalog[i].name + \" x\" + catalog[i].stockCount);\n }\n }\n}\n```\n\n\nThe array holds three references to three different `Product` objects. The class wrote the rules once. The `new` calls produced three distinct things that follow those rules.\n\n---\n\n# References: Two Variables Can Point at One Object\n\nIn `Product mouse = new Product();`, the variable `mouse` doesn't hold the object itself. It holds a **reference** to the object. The object lives somewhere in memory, and the reference is the address used to find it. Assigning one object variable to another copies the reference, not the object.\n\n\n```java\npublic class ReferenceCopy {\n public static void main(String[] args) {\n Product mouse = new Product();\n mouse.name = \"Wireless Mouse\";\n mouse.price = 29.99;\n mouse.stockCount = 12;\n\n Product alias = mouse; // copies the reference, not the object\n alias.stockCount = alias.stockCount - 1;\n\n System.out.println(\"mouse.stockCount = \" + mouse.stockCount);\n System.out.println(\"alias.stockCount = \" + alias.stockCount);\n }\n}\n```\n\n\nAfter `Product alias = mouse;`, both variables point to the **same** object. Writing through `alias` is visible through `mouse`, because there's only one object behind the two names. Compare that to primitives: `int a = 5; int b = a; b = 6;` leaves `a` at `5`, because primitives copy values. References copy the pointer.\n\nThe same situation as a picture.\n\n\n```mermaid\nflowchart LR\n Mouse[mouse]:::cyan\n Alias[alias]:::cyan\n Obj[\"Product object
name = Wireless Mouse
price = 29.99
stockCount = 11\"]:::green\n\n Mouse --> Obj\n Alias --> Obj\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nTwo arrows, one object. Anything done through one arrow is visible through the other. Writing `cartCopy = cart;` does not create an independent copy. The result is a second name for the same cart.\n\nFor an independent copy, create a new object and copy the fields over manually (or use a copy-construction pattern, which the Inheritance section covers more thoroughly).\n\n\n```java\npublic class IndependentCopy {\n public static void main(String[] args) {\n Product mouse = new Product();\n mouse.name = \"Wireless Mouse\";\n mouse.price = 29.99;\n mouse.stockCount = 12;\n\n Product copy = new Product();\n copy.name = mouse.name;\n copy.price = mouse.price;\n copy.stockCount = mouse.stockCount;\n\n copy.stockCount = 99;\n\n System.out.println(\"mouse.stockCount = \" + mouse.stockCount);\n System.out.println(\"copy.stockCount = \" + copy.stockCount);\n }\n}\n```\n\n\nNow `mouse` and `copy` are independent because `copy` was built from a separate `new Product()`. The field assignments in the middle do the manual copying.\n\n### What's Wrong With This Code?\n\n\n```java\npublic class CopyMistake {\n public static void main(String[] args) {\n Product original = new Product();\n original.name = \"Notebook\";\n original.stockCount = 50;\n\n Product backup = original;\n original.stockCount = 0;\n\n System.out.println(\"Backup stock: \" + backup.stockCount);\n }\n}\n```\n\n\nThe author expected `backup` to keep `stockCount = 50` as a safety copy of the original. Running it prints `Backup stock: 0` because `backup = original` only copies the reference. Setting `original.stockCount = 0` modifies the one object both variables refer to.\n\n**Fix:** Allocate a new `Product` and copy the fields explicitly.\n\n\n```java\npublic class CopyFixed {\n public static void main(String[] args) {\n Product original = new Product();\n original.name = \"Notebook\";\n original.stockCount = 50;\n\n Product backup = new Product();\n backup.name = original.name;\n backup.stockCount = original.stockCount;\n\n original.stockCount = 0;\n\n System.out.println(\"Backup stock: \" + backup.stockCount);\n }\n}\n```\n\n\nNow `backup` is a separate object, so changes to `original` don't touch it. The fix prints `Backup stock: 50`.\n\n---\n\n# The `null` Reference\n\nA reference variable has to either point at an object or hold the special value `null`. `null` means \"no object\". It's the default for any uninitialized reference field, and it's a legal value to assign explicitly.\n\n\n```java\npublic class NullExamples {\n public static void main(String[] args) {\n Product current = null; // legal: no product yet\n System.out.println(current); // prints null\n\n current = new Product();\n current.name = \"Mouse\";\n System.out.println(current.name); // prints Mouse\n\n current = null; // we let go of the reference\n System.out.println(current); // prints null again\n }\n}\n```\n\n\n`null` represents an empty slot. The variable exists, but it isn't currently pointing at a product. It's useful for \"no value picked yet\" or \"lookup returned no match.\"\n\n### What Happens When You Call a Method on `null`\n\nUsing the dot operator on a `null` reference makes the Java runtime throw a **`NullPointerException`**, abbreviated `NPE`. The dot operator needs a real object on its left side. There's nothing to reach into when the slot is empty.\n\n\n```java\npublic class NullCallFails {\n public static void main(String[] args) {\n Product missing = null;\n System.out.println(missing.name); // throws NullPointerException\n }\n}\n```\n\n\nThe exact wording of the message depends on the Java version. Java 14 and later include the variable name (`\"missing\" is null`) which is a big help when debugging. The program stops with an error. Reading a field from no-object is not allowed.\n\nA common scenario is a \"find\" method that might not find anything. If `findProduct(\"ABC\")` returns `null` when no product matches, the caller needs to check before using the result.\n\n\n```java\npublic class GuardedAccess {\n public static void main(String[] args) {\n Product result = findProduct(\"XYZ\");\n\n if (result != null) {\n System.out.println(\"Found: \" + result.name);\n } else {\n System.out.println(\"No product found.\");\n }\n }\n\n public static Product findProduct(String id) {\n // Pretend lookup failed. Returning null is one way to say \"not found\".\n return null;\n }\n}\n```\n\n\nThe `if (result != null)` guard is what stops the `NullPointerException`. Ask \"could this be null?\" before using the dot operator on any reference not just created with `new`.\n\n---\n\n# Memory: Stack and Heap, in Brief\n\nA deep memory model isn't required to use classes, but a quick picture helps the rest of the OOP section make sense. Java keeps local variables (the ones declared inside methods) in a region called the **stack**. Objects created with `new` live in a region called the **heap**. A reference variable on the stack holds the address of an object on the heap.\n\n\n```mermaid\nflowchart LR\n subgraph Stack[\"Stack (local variables)\"]\n Mouse[mouse]:::cyan\n Cable[cable]:::cyan\n end\n subgraph Heap[\"Heap (objects)\"]\n Obj1[\"Product
name = Mouse
price = 29.99
stockCount = 12\"]:::green\n Obj2[\"Product
name = Cable
price = 9.99
stockCount = 100\"]:::orange\n end\n\n Mouse --> Obj1\n Cable --> Obj2\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nWhen `main` finishes, its stack frame disappears and the variables `mouse` and `cable` go away. The objects on the heap stick around until nothing references them anymore, at which point Java's garbage collector reclaims the memory. The [Memory Model](/learn/java/memory-model-basics) section covers this in detail. The takeaway is that **the variable and the object are two different things**, which is what makes assignment copy the reference rather than the object.\n\nThis also explains why `null` is a normal value for a reference variable. A reference is essentially an arrow, and `null` is the special \"arrow pointing at nothing\" value.\n\n---\n\n# A Slightly Larger Example: Cart Items\n\nCombine fields, methods, and multiple objects into something closer to real code. Consider a class that represents one line item in a shopping cart. Each line knows its product name, the price per unit, and the quantity, and it can produce its own subtotal.\n\n\n```java\npublic class CartItem {\n public String productName;\n public double pricePerUnit;\n public int quantity;\n\n public double subtotal() {\n return pricePerUnit * quantity;\n }\n\n public void printLine() {\n System.out.println(productName + \" x\" + quantity + \" @ $\" + pricePerUnit + \" = $\" + subtotal());\n }\n}\n```\n\n\n`subtotal` returns a `double`. `printLine` prints a formatted line and calls `subtotal()` to get the value. Inside `printLine`, calling `subtotal()` works without an object prefix because the method is already operating on a specific cart item.\n\nA small driver builds three items and prints them:\n\n\n```java\npublic class CartDriver {\n public static void main(String[] args) {\n CartItem mouse = new CartItem();\n mouse.productName = \"Wireless Mouse\";\n mouse.pricePerUnit = 29.99;\n mouse.quantity = 1;\n\n CartItem cable = new CartItem();\n cable.productName = \"USB Cable\";\n cable.pricePerUnit = 9.99;\n cable.quantity = 3;\n\n CartItem book = new CartItem();\n book.productName = \"Notebook\";\n book.pricePerUnit = 4.50;\n book.quantity = 2;\n\n mouse.printLine();\n cable.printLine();\n book.printLine();\n\n double cartTotal = mouse.subtotal() + cable.subtotal() + book.subtotal();\n System.out.println(\"Cart total: $\" + cartTotal);\n }\n}\n```\n\n\nEach `CartItem` object has its own `productName`, `pricePerUnit`, and `quantity`, and each one knows how to compute its own subtotal. The driver adds them up to get the cart total. The class wrote the recipe once; the driver instantiated three objects from it and used them.\n\nThis shape, one class describing a thing and one driver class wiring them together, is the structure used throughout the rest of the OOP section. Constructors remove the awkward \"create, then assign field, then assign field\" sequence and make sure new objects start out with real values.\n\n---\n\n# Looking Ahead\n\nSeveral pieces are deliberately out of scope so this lesson stays focused on what classes and objects are:\n\n- **Constructors** are the standard way to initialize an object's fields when calling `new`.\n- **`this`** is the explicit reference to the current object. It only matters in specific situations, covered shortly.\n- **Access modifiers** (`public`, `private`, `protected`, package-private) control who can read and write fields and call methods. The Access Modifiers lesson covers the rules.\n- **Getters and setters** wrap field access in methods, which is the conventional Java style. Direct `public` fields are used here for clarity.\n- **`static`** declares methods and fields that belong to the class rather than to any object. Every method in this lesson is an instance method.\n\nEach of these is covered later. Together with what's in this lesson, they form the toolkit for writing well-shaped Java classes.\n\n---\n\n# Summary\n\n- A class is a blueprint that defines fields (state) and methods (behavior) for a kind of thing. An object is a concrete instance of a class, built at runtime with `new ClassName()`.\n- The dot operator (`.`) reads or writes a field, or calls an instance method, on a specific object: `mouse.name`, `mouse.printSummary()`.\n- Each object created from a class has its own independent copy of the instance fields. Changing one object's fields never changes another's.\n- A class is a type that lives in source and bytecode. An object is a runtime entity that lives on the heap. One class can produce many objects.\n- Object variables hold **references**, not the object itself. Assigning one object variable to another copies the reference, so both names point to the same object. To get an independent copy, allocate a new object and copy the fields by hand.\n- Newly created objects start with default field values: `0` for numeric primitives, `false` for `boolean`, the null character for `char`, and `null` for any reference type. Local variables inside methods have no defaults.\n- `null` means \"no object\". Calling a method or reading a field on a `null` reference throws a `NullPointerException` at runtime, so guard with `if (ref != null)` whenever a reference might be empty.\n- Each object reference variable lives on the stack, and the object it points to lives on the heap. That separation is what makes references work the way they do.\n\nConstructors are the standard way to initialize an object's fields when calling `new` so half-filled instances don't show up.\n\nThe next lesson covers constructors, the standard way to initialize an object's fields when calling `new` so half-filled instances don't show up.","pageType":"java"}

Classes & Objects

Get Premium