{"title":"Object Class","description":"","content":"Every class we've written so far has secretly extended `java.lang.Object`. That's what makes `Product`, `Book`, and `Customer` all comparable, hashable, and printable using the same set of methods. This lesson is a guided tour: what `Object` provides, what each method does by default, and which lessons cover the important overrides in detail.\n\n---\n\n# The Universal Root\n\n`java.lang.Object` sits at the top of Java's class hierarchy. Every other class in the language, whether it ships with the JDK or you wrote it yourself this morning, eventually traces its ancestry back to `Object`. There is no class above it, and there is no reference type that escapes it.\n\n\n```mermaid\nflowchart TD\n Object[\"java.lang.Object\"]:::orange\n\n Product[\"Product\"]:::cyan\n Customer[\"Customer\"]:::cyan\n String[\"String\"]:::cyan\n ArrayList[\"ArrayList\"]:::cyan\n\n Book[\"Book extends Product\"]:::teal\n AudioBook[\"AudioBook extends Book\"]:::green\n\n Object --> Product\n Object --> Customer\n Object --> String\n Object --> ArrayList\n\n Product --> Book\n Book --> AudioBook\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 diagram shows what's really going on. `Product`, `Customer`, `String`, and `ArrayList` all sit one level below `Object`. `Book` extends `Product`, which extends `Object`. `AudioBook` extends `Book`, which extends `Product`, which extends `Object`. No matter how deep the inheritance chain goes, the very top is always `Object`.\n\nThis isn't a convention or a recommendation. It's a structural rule the language enforces. If you write a class with no explicit `extends` clause, the compiler inserts `extends Object` for you. If you write a class that does extend something, that something either is `Object` or eventually leads to `Object`. There is no third option.\n\nThe reason this matters is that every object in a Java program has a known minimum set of capabilities. Any object can be asked for a string form of itself, compared to another object for equality, queried for a hash code, or queried for its runtime class. Any object can be placed into a generic container that accepts `Object`. These are not features a class has to add. They come along the moment a class is declared.\n\n\n```java\npublic class Product {\n String name;\n double price;\n\n public Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n\n public static void main(String[] args) {\n Product mouse = new Product(\"Wireless Mouse\", 29.99);\n\n System.out.println(mouse.toString());\n System.out.println(mouse.hashCode());\n System.out.println(mouse.getClass());\n }\n}\n```\n\n\nNothing in the `Product` source declares `toString`, `hashCode`, or `getClass`. All three are inherited from `Object`, and all three work on the very first instance we build. The class didn't have to ask for these methods. It got them by being a class.\n\nThe hex part of `Product@1540e19d` is the identity hash code in hexadecimal, derived from the object's memory address. The exact value varies per run and per JVM.\n\n---\n\n# The Implicit `extends Object`\n\nA class without an explicit `extends` clause silently extends `Object`. The two declarations below are exactly equivalent.\n\n\n```java\npublic class Product {\n String name;\n}\n```\n\n\n\n```java\npublic class Product extends Object {\n String name;\n}\n```\n\n\nThe compiler treats them the same way. No bytecode difference, no behavior difference. Most Java code uses the short form because the inheritance is implicit.\n\nWhen a class does extend something else, the chain just gets longer. `Book extends Product` doesn't bypass `Object`. It goes through `Product` to reach `Object`.\n\n\n```java\npublic class Product {\n String name;\n double price;\n\n public Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n}\n\npublic class Book extends Product {\n String author;\n\n public Book(String name, double price, String author) {\n super(name, price);\n this.author = author;\n }\n\n public static void main(String[] args) {\n Book book = new Book(\"Effective Java\", 39.99, \"Joshua Bloch\");\n\n System.out.println(book instanceof Product);\n System.out.println(book instanceof Object);\n }\n}\n```\n\n\nA `Book` is a `Product`, and a `Book` is also an `Object`. The chain `Book -> Product -> Object` means every `Book` is all three things at once.\n\nArrays follow the same rule, even though they aren't classes you declare with a `class` keyword. Every array type has `Object` as its superclass.\n\n\n```java\npublic class ArrayRoot {\n public static void main(String[] args) {\n String[] productNames = {\"Mouse\", \"Cable\", \"Headphones\"};\n int[] quantities = {1, 2, 3};\n\n System.out.println(productNames instanceof Object);\n System.out.println(quantities instanceof Object);\n\n Object asObject = productNames;\n System.out.println(asObject.getClass().getSimpleName());\n }\n}\n```\n\n\nA `String[]` is an `Object`. So is an `int[]`. You can assign either to an `Object` variable, call `getClass()` on it, or put it into a method that accepts `Object`. The array machinery is wired into the same root hierarchy as everything else.\n\nPrimitives are the one exception. An `int`, a `double`, a `boolean`, and the other six primitives are **not** objects. They have no methods, no superclass, no `getClass()` to call. The bridge between primitives and the object world is the wrapper classes (`Integer`, `Double`, `Boolean`, and so on). A wrapper class like `Integer` is a normal class that extends `Object`, so its instances do get the full `Object` API. The raw primitive value does not.\n\n\n```java\npublic class PrimitivesVsObjects {\n public static void main(String[] args) {\n int rawQuantity = 5;\n Integer wrappedQuantity = 5;\n\n // rawQuantity.toString(); // would not compile, int has no methods\n System.out.println(wrappedQuantity.toString());\n System.out.println(wrappedQuantity instanceof Object);\n }\n}\n```\n\n\nThe commented line wouldn't compile because `int` isn't a reference type. The wrapper instance, on the other hand, is a full-fledged object that inherits everything `Object` offers.\n\n---\n\n# A Tour of `Object`'s Methods\n\n`Object` defines a small set of methods that every object in the language inherits. Here's the full list with default behaviors.\n\n\n| Signature | Default Behavior |\n| --- | --- |\n| `String toString()` | Returns class name + `@` + hex of identity hash code |\n| `boolean equals(Object obj)` | Returns `true` only if both references point to the same object |\n| `int hashCode()` | Returns an identity hash code derived from the object's memory state |\n| `Class getClass()` | Returns the runtime `Class` object for this instance. Cannot be overridden |\n| `Object clone()` | Returns a field-by-field copy, but only if the class implements `Cloneable` |\n| `void finalize()` | Called by the garbage collector before reclaiming the object. Deprecated since Java 9, marked for removal in Java 18 |\n| `void wait()`, `void wait(long)`, `void wait(long, int)` | Used with `synchronized` for inter-thread waiting |\n| `void notify()` | Wakes one thread waiting on this object's monitor |\n| `void notifyAll()` | Wakes all threads waiting on this object's monitor |\n\n\nThe methods commonly overridden in real code are at the top of the list: `toString`, `equals`, `hashCode`. The rest are used less often, and a few should not be used at all.\n\nThe diagram below groups the methods by what they're for.\n\n\n```mermaid\nflowchart TD\n Object[\"java.lang.Object\"]:::orange\n\n Identity[\"Identity & Equality
toString()
equals()
hashCode()
getClass()\"]:::cyan\n\n Copying[\"Copying
clone()\"]:::teal\n\n Cleanup[\"Cleanup (deprecated)
finalize()\"]:::red\n\n Threads[\"Inter-thread Communication
wait()
notify()
notifyAll()\"]:::green\n\n Object --> Identity\n Object --> Copying\n Object --> Cleanup\n Object --> Threads\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\nFour buckets, four jobs. Identity and equality is the bucket used most often. Copying matters when duplicating an object. The cleanup hook exists for historical reasons and is best avoided. The threading methods are how objects coordinate when multiple threads share them.\n\nThe rest of this lesson walks through each bucket at a high level. The lessons that follow take the busy ones (equals, hashCode, toString, clone) and turn each into a full lesson.\n\n---\n\n# `toString()` and Default Behavior\n\n`toString()` returns a string description of the object. Java calls it whenever an object is concatenated with a string (`\"Item: \" + product`) or passed to `System.out.println`.\n\nThe default implementation in `Object` looks like this:\n\n\n```java\npublic String toString() {\n return getClass().getName() + \"@\" + Integer.toHexString(hashCode());\n}\n```\n\n\nThat gives the fully qualified class name, an `@` sign, and the identity hash code in hexadecimal. Useful for debugging, mostly useless for real output. Here is what happens when a `Product` is printed without overriding the method.\n\n\n```java\npublic class Product {\n String name;\n double price;\n\n public Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n\n public static void main(String[] args) {\n Product mouse = new Product(\"Wireless Mouse\", 29.99);\n Product cable = new Product(\"USB Cable\", 9.99);\n\n System.out.println(mouse);\n System.out.println(cable);\n System.out.println(\"Item: \" + mouse);\n }\n}\n```\n\n\nThe two products print with different hex suffixes because each has a different identity hash. The hex part differs across machines and even between runs of the same program. The class name on the left is what Java knows. The hex on the right is essentially \"where this object lives in memory, scrambled a bit.\" Neither tells the reader anything useful about a product, which is why almost every meaningful class overrides `toString`. The default `toString` is debug-only output, and most classes whose value is meant to be read replace it.\n\n---\n\n# `equals()` and `hashCode()` and Default Behavior\n\n`equals(Object obj)` answers the question \"are these two references logically the same object?\" `hashCode()` returns an integer that goes hand-in-hand with equality, and is used by hash-based collections like `HashMap` and `HashSet` to bucket objects efficiently.\n\nThe default `equals` in `Object` is reference equality. It returns `true` only when both references point to the exact same object in memory. That's the same comparison `==` does for reference types.\n\n\n```java\npublic class Product {\n String name;\n\n public Product(String name) {\n this.name = name;\n }\n\n public static void main(String[] args) {\n Product a = new Product(\"Mouse\");\n Product b = new Product(\"Mouse\");\n Product c = a;\n\n System.out.println(\"a.equals(b): \" + a.equals(b));\n System.out.println(\"a.equals(c): \" + a.equals(c));\n System.out.println(\"a == b: \" + (a == b));\n System.out.println(\"a == c: \" + (a == c));\n }\n}\n```\n\n\n`a` and `b` both wrap the string `\"Mouse\"`, but they're two separate `Product` objects with two separate identities, so the default `equals` reports `false`. `c` is just another reference to the same object as `a`, so `equals` returns `true`. That matches what `==` does, because the default `equals` is essentially `this == other` plus a null check on the argument.\n\nThe default `hashCode` returns an integer derived from the object's identity. Two `Product` instances built from the same name almost always get different hash codes, because the default implementation doesn't look at field values, only at object identity.\n\n\n```java\npublic class Product {\n String name;\n\n public Product(String name) {\n this.name = name;\n }\n\n public static void main(String[] args) {\n Product a = new Product(\"Mouse\");\n Product b = new Product(\"Mouse\");\n\n System.out.println(\"a.hashCode(): \" + a.hashCode());\n System.out.println(\"b.hashCode(): \" + b.hashCode());\n }\n}\n```\n\n\nThe actual numbers depend on the run, and two distinct objects holding the same data give different hash codes. This is almost never the right behavior for value-like classes such as `Product`, `Customer`, or `Order`. Putting two `Product(\"Mouse\")` instances into a `HashSet` causes the default `equals` and `hashCode` to treat them as different items, and the set accepts both. The defaults work only when \"same object in memory\" is the right notion of equality, which for most data-carrying classes it isn't.\n\n---\n\n# `getClass()` and the Runtime Class\n\n`getClass()` returns the runtime `Class` object for the instance. Unlike `toString` and `equals`, this method is `final` on `Object`, which means it cannot be overridden. `getClass()` returns the actual runtime type of the instance.\n\n\n```java\npublic class Product {\n String name;\n\n public Product(String name) {\n this.name = name;\n }\n}\n\npublic class Book extends Product {\n String author;\n\n public Book(String name, String author) {\n super(name);\n this.author = author;\n }\n\n public static void main(String[] args) {\n Product mouse = new Product(\"Wireless Mouse\");\n Book bookAsProduct = new Book(\"Effective Java\", \"Joshua Bloch\");\n\n Product reference = bookAsProduct;\n\n System.out.println(mouse.getClass());\n System.out.println(bookAsProduct.getClass());\n System.out.println(reference.getClass());\n System.out.println(reference.getClass().getSimpleName());\n }\n}\n```\n\n\nFirst, the variable `reference` is declared as `Product`, but `getClass()` reports `Book`. `getClass()` always returns the object's actual type, not the declared type of the reference. Second, `getSimpleName()` strips off any package qualifier and returns just the class name, which is what most readable code uses.\n\nThe `Class` object is the entry point to Java's reflection API. From it, the methods, fields, constructors, and annotations a class declares can be queried. For this lesson, the key points are that `getClass()` exists, that it's final, and that it returns the real runtime type.\n\nA common pattern is to use `getClass()` inside an override to ensure two objects are of the same runtime type before comparing fields.\n\n\n```java\npublic class Product {\n String name;\n\n public Product(String name) {\n this.name = name;\n }\n\n public static void main(String[] args) {\n Product mouse = new Product(\"Wireless Mouse\");\n Product cable = new Product(\"USB Cable\");\n\n System.out.println(mouse.getClass() == cable.getClass());\n System.out.println(mouse.getClass().getName());\n }\n}\n```\n\n\nBoth objects are `Product` instances, so their `Class` objects are equal by `==` (there's exactly one `Class` object per loaded class, so reference comparison is fine). `getName` gives the fully qualified name, while `getSimpleName` gives just the trailing class name.\n\n---\n\n# `clone()`, `finalize()`, `wait`/`notify`/`notifyAll`\n\nThe remaining methods on `Object` are more specialized. Each gets a brief mention here, with pointers to where the real coverage lives.\n\n### `clone()`\n\n`Object.clone()` is a protected method that produces a field-by-field copy of an object. The protection level is a deliberate restriction: `someProduct.clone()` cannot be called from outside the class. The class has to opt in by implementing the `Cloneable` marker interface and usually exposing its own `public` `clone` method that delegates to `super.clone()`.\n\n\n```java\npublic class Product implements Cloneable {\n String name;\n double price;\n\n public Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n\n @Override\n public Product clone() {\n try {\n return (Product) super.clone();\n } catch (CloneNotSupportedException e) {\n throw new AssertionError(e);\n }\n }\n\n public static void main(String[] args) throws Exception {\n Product original = new Product(\"Wireless Mouse\", 29.99);\n Product copy = original.clone();\n\n System.out.println(original.name + \" $\" + original.price);\n System.out.println(copy.name + \" $\" + copy.price);\n System.out.println(original == copy);\n }\n}\n```\n\n\nThe copy carries the same field values as the original, but it's a separate object. The `==` check confirms they aren't the same reference. This example doesn't show the difference between **shallow** and **deep** cloning, or the issues around mutable fields, arrays, and inherited state. Cloning correctly is harder than it looks, and copy constructors or static factory methods are often preferred over `clone`.\n\n### `finalize()`\n\n`finalize()` was originally a hook the garbage collector called before reclaiming an object's memory. The idea was to release native resources or do last-minute cleanup. In practice, `finalize` turned out to be slow, unreliable, and a source of bugs. It was deprecated in Java 9, marked for removal in Java 18, and is no longer recommended.\n\nFor cleanup at the end of an object's life, use `try-with-resources` for anything that implements `AutoCloseable`. For the rare cases that need a backstop, `java.lang.ref.Cleaner` replaces what `finalize` used to do, without the performance and correctness problems.\n\nThere's no useful default behavior to demonstrate. The method exists and may appear in legacy code; new code should leave it alone.\n\n### `wait()`, `notify()`, `notifyAll()`\n\nThese three methods are how objects coordinate when multiple threads share them. They are tied to `synchronized` blocks: a thread that holds an object's monitor can call `wait()` to release the monitor and pause, and another thread can call `notify()` or `notifyAll()` to wake one or all waiting threads.\n\n\n```java\npublic class Inventory {\n public synchronized void waitForStock() throws InterruptedException {\n // releases the monitor and waits\n wait();\n }\n\n public synchronized void announceStock() {\n // wakes any threads that are waiting on this inventory\n notifyAll();\n }\n}\n```\n\n\nThis is a sketch, not a runnable example. These three methods exist on every object because every object can act as a monitor for synchronization.\n\n---\n\n# Why It Matters: Universal Containers and Behavior\n\nHaving every reference type extend `Object` isn't just a tidy hierarchy diagram. It enables a lot of Java's everyday machinery without each class having to opt in.\n\nThe most visible payoff is in containers. An `Object[]` can hold instances of any class. A `List

Object Class

Get Premium