Init Blocks, Cloning & Serialization
A static block { } runs once, the moment the class loads — best for initializing static variables. An instance block runs every time an object is created (before the constructor).
clone() is a method from the Object class that creates a copy of an existing object (you need to implement the Cloneable interface).
Implementing the Serializable interface lets you convert an object into bytes (e.g. to save to a file or send over a network), and later deserialize it back into an object.
class Config implements Cloneable, Serializable {
static { System.out.println("Loaded once!"); }
int value = 10;
}- static block = runs once when the class loads
- clone() = a copy of the object
- Serializable = save/send an object, rebuild it later
Shallow clone (the default clone() behavior, inherited from the Object class) only copies top-level fields — if a field is itself an object (a reference type), both clones point to the *same* nested object (changing it in one shows up in the other too, since the reference was copied, not the object).
Deep clone copies nested objects individually too — a completely independent copy, but you have to implement it manually (calling clone() on every nested object too, recursively).
| Shallow Clone | Deep Clone | |
|---|---|---|
| Primitive fields | Get copied | Get copied |
| Reference fields (objects) | Same object shared | A new independent copy is made |
| Implementing it | Easy (default clone()) | Manual, clone every nested object |
// Shallow: dono objects ka "address" field same object point karta hai
Person clone = original.clone();
clone.address.city = "Mumbai"; // original.address.city bhi change ho jaayega!When you need to skip certain fields during serialization (like a password, or a re-computable cache, or a field that isn't even Serializable, like a Thread), mark them transient — these fields get ignored while serializing, and get their default value (0/null) on deserialization.
class User implements Serializable {
String username;
transient String password; // serialize NAHI hoga
}Defining a static final long serialVersionUID in a Serializable class is best practice — it's a "version number" that tells you what the class's structure looked like when the object was serialized. If you don't write it explicitly, the JVM computes one automatically (from the class structure), but that can change depending on compiler/platform.
If the class changes later (a new field gets added) and you try to deserialize old serialized data, the JVM checks the serialVersionUID and detects an incompatible version (InvalidClassException) — keeping an explicit UID lets you control when something counts as "compatible".
When a class loads for the first time: (1) static variables/blocks run once in their declaration order (only once for the entire program). Every time an object gets created with "new": (2) instance variables/blocks run in declaration order, (3) then the constructor runs.
So a static block runs first (once, at class load), an instance block runs for every object, just before the constructor. With inheritance the order gets even more interesting — parent's static blocks first, then child's static blocks, then (when the object is being created) parent's instance blocks + constructor, then child's.