Summary

Instance Variables

1. Multiple copies of memory will be allocated for multiple objects.

2. Instance variable is related to instance (object) of the class, so when you change data of one object, it does not affect other objects.

3. Instance variables must be accessed using a reference variable that contains the object.

4. Ways to access instance variables:

   a) Using reference variable

   Hello h=new Hello();
   h.a=90;// VALID

   b) Directly using object reference

   new Hello().a=90;// VALID (Not recommended – no reusability)

5. If you access an instance variable using a null reference,

   → java.lang.NullPointerException occurs at runtime.

   Hello h=null;
   h.a=90;// Runtime Exception

6. If you try to access an instance variable using class name,

   → Compile-time error:

   non-static variable a cannot be referenced from a static context

   Hello.a=90;// ERROR

---

Static Variables

1. Only one copy of memory is allocated for static variables, shared across all objects.
2. Static variables belong to the class, so changes affect all objects.
3. Static variables can be accessed using the class name directly (object not required), but they can also be accessed using an object reference.
4. Ways to access static variables:

a) Using class name (recommended)

Hello.b=90;

b) Using reference variable with null

Hello h=null;
h.b=90;// VALID

c) Using reference variable with object

Hello h=new Hello();
h.b=90;// VALID

---

🧠 Quick Comparison

Feature	Instance Variable	Static Variable
Memory	Multiple copies (per object)	Single copy (shared)
Belongs to	Object	Class
Access	Object reference required	Class name preferred
Null reference access	Exception	✔ Works
Impact of change	Only that object	All objects

---

🚀 Key Takeaways

• Instance → object-specific
• Static → class-level shared
• Always prefer:
  • object.var → for instance
  • Class.var → for static

d) Directly using object reference

new Hello().b=90;

---

✔ Compiler Behavior

When you refer to a static variable using anything other than class name,

the compiler internally converts it to class name:

a)Hello h=null;
h.b=90;   →convertedtoHello.b=90;

b)Hello h=new Hello();
h.b=90;   →convertedtoHello.b=90;

c)new Hello().b=90;
   →convertedtoHello.b=90;

---

Initialization Blocks

✔ Rule

A class can contain only five types of members:

• Variables
• Blocks
• Constructors
• Methods
• Inner Classes

You cannot place normal Java statements directly inside a class.

---

✔ Example

class Hello{
    int a;// VALID
    a=10;// INVALID
}

class Hai{
    int b=10;// VALID
    System.out.println(b);// INVALID
}

---

✔ Important Points

1. Instance Initialization Block (IIB)

• Executed automatically after object creation

1. Static Initialization Block (SIB)

• Executed automatically when class is loaded

1. Instance variables are usually initialized inside instance block
2. Static variables should be initialized inside static block (but can also be initialized inside instance block)
3. Instance block executes every time an object is created
4. Static block executes only once when class is loaded
5. Class is loaded only once when JVM uses it for the first time
6. Instance variables cannot be accessed directly from static context → must use object reference

---

Local Variables

1. JVM does not initialize local variables with default values → must be initialized before use
2. Scope of local variable is within the block/method/constructor
3. Local variables are not class members → cannot be accessed using class name or object
4. Local variables cannot be static
5. Only final modifier is allowed for local variables
6. Memory for local variables is allocated in STACK MEMORY

---

🧠 Quick Summary

Concept	Key Point
Static access	Always treated as ClassName.variable
IIB	Runs on every object creation
SIB	Runs once when class loads
Local variables	No default value, stack memory
Class members	Only 5 allowed types

---

🚀 Final Takeaways

• Static → class-level (shared)
• Instance → object-level
• Local → method/block-level
• JVM behavior:
  • Static → load time
  • Instance → object creation
  • Local → runtime inside method