feat: implement Customer serialization and deserialization using Object Streams

WHAT:
- Created a `Customer` class implementing `Serializable` with fields:
  - `custID` (auto-generated unique ID using static counter),
  - `name`,
  - `phno`.
- Implemented serialization (`ObjectOutputStream`) to store multiple customers in a file.
- Implemented deserialization (`ObjectInputStream`) to retrieve and display customers from file.

HOW:
- Serialization:
  - Write the number of customers (`list.length`) first.
  - Serialize each `Customer` object with `writeObject()`.
- Deserialization:
  - Read count using `readInt()`.
  - Read and cast objects back to `Customer[]`.
- Used `toString()` for clean formatted customer display.

WHY:
- Demonstrates how to persist Java objects (with state) into a file.
- Ensures objects can be reconstructed later without manual parsing.
- Useful for lightweight persistence when databases are unnecessary.

REAL-WORLD APPLICATIONS:
- Saving customer/user profiles in desktop applications.
- Temporary caching of session data in serialized form.
- Quick prototyping of object persistence without DB integration.

NOTES:
- `static` fields (like `count`) are not serialized; IDs regenerate with each run.
- Must maintain same class definition when deserializing to avoid `InvalidClassException`.

NEXT IMPROVEMENTS:
- Add `serialVersionUID` for better version control during deserialization.
- Improve uniqueness of `custID` across multiple runs (e.g., UUID instead of static counter).
- Enhance program with search functionality (filter by name/ID).

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section23JavaIOStreams/Serialisation Storing Data in a File/src/printID.java

@@ -24,14 +24,15 @@ public String toString() {
 }
 
 class PrintID {
-    /*public static void main(String[] args) throws Exception {
+    /*
+    public static void main(String[] args) throws Exception {
         Customer list[] = {
                 new Customer("Smith", "123456789"),
                 new Customer("Johnson", "1234567"),
                 new Customer("Ajay", "12345345")
         };
 
-        FileOutputStream fos = new FileOutputStream("C:\\Users\\somes\\Downloads\\JAVA SE\\Section23JavaIOStreams\\Serialisation Storing Data in a File\\MyJAVA\\Customer.txt");
+        FileOutputStream fos = new FileOutputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Customer.txt");
         ObjectOutputStream oos = new ObjectOutputStream(fos);
 
         oos.writeInt(list.length); // Writing array length first
@@ -41,12 +42,13 @@ class PrintID {
         oos.close();
         fos.close();
         System.out.println("Customer data serialized successfully.");
-    }*/
+    }
+    */
 
     public static void main(String[] args) throws Exception {
-        java.util.Scanner sc =new java.util.Scanner(System.in);
+        java.util.Scanner sc = new java.util.Scanner(System.in);
 
-        FileInputStream fis = new FileInputStream("C:\\Users\\somes\\Downloads\\JAVA SE\\Section23JavaIOStreams\\Serialisation Storing Data in a File\\MyJAVA\\Customer.txt");
+        FileInputStream fis = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/Customer.txt");
         ObjectInputStream ois = new ObjectInputStream(fis);
 
         int length = ois.readInt(); // Read-number of customers stored
@@ -56,15 +58,60 @@ public static void main(String[] args) throws Exception {
 
         String name = sc.nextLine();
         for (int i = 0; i < length; i++) {
-            customers[i] = ( Customer ) ois.readObject();
+            customers[i] = (Customer) ois.readObject();
         }
 
         ois.close();
         fis.close();
 
         System.out.println("Deserialized Customer Data:");
+
         for (Customer c : customers) {
             System.out.println(c);
         }
     }
-}
+}
+
+/*
+1. Serializable Interface
+   - `Customer implements Serializable` → ye batata hai ki Customer objects ko
+     byte-stream me convert kiya ja sakta hai (serialize) aur wapas object me laaya ja sakta hai (deserialize).
+   - Agar Serializable implement nahi karte to `NotSerializableException` aata.
+
+2. Static field ka behaviour
+   - `static int count` serialise nahi hota (kyunki static class level property hoti hai).
+   - Jab object wapas deserialize hota hai, uska static field fresh hota hai (default class ke sath).
+   - Is case me sirf `custID`, `name`, aur `phno` serialise hote hain.
+
+3. ObjectOutputStream (Serialization)
+   - `ObjectOutputStream oos = new ObjectOutputStream(fos)`
+   - `oos.writeInt(list.length)` → pehle array ka length likh diya (taaki read karte waqt pata ho kitne objects hain).
+   - `oos.writeObject(c)` → har Customer object file me serialize kiya gaya.
+
+4. ObjectInputStream (Deserialization)
+   - `int length = ois.readInt()` → pehle number of customers read kiya.
+   - `customers[i] = (Customer) ois.readObject()` → file se ek ek object read karke array me store kiya.
+   - `readObject()` ko typecast karna padta hai.
+
+5. toString() Override
+   - `Customer` class ne `toString()` override kiya hai → isliye print karne par directly readable string aata hai:
+     ```
+     Customer ID: C1
+     Name: Smith
+     Phno: 123456789
+     ```
+
+6. File Path
+   - Serialization aur Deserialization dono ek hi file path use karte hain
+     (`Customer.txt` binary file hoti hai, text jaisa readable nahi dikhega).
+
+7. Scanner ka use
+   - Deserialization code me tumne `Scanner` se ek name input liya hai,
+     lekin uska use filtering ke liye nahi ho raha. Agar chaho to loop me
+     input name se match karke sirf wahi customer print kar sakte ho.
+
+- `try-with-resources` use karo taaki streams automatically close ho jaye.
+- `serialVersionUID` add karo class me (recommended for Serializable classes).
+  ```java
+  private static final long serialVersionUID = 1L;
+*/