feat: Implement Singleton design pattern with CoffeeMachine class

WHAT the code does:
- Defines CoffeeMachine with private fields for coffee, milk, water, and sugar quantities.
- Uses a **private constructor** to prevent external instantiation.
- Maintains a static private reference `my` to hold the single instance.
- Provides a static factory method getInstance():
  - Creates a new CoffeeMachine only if none exists.
  - Returns the same object reference for all calls.
- Adds utility methods:
  - fillWater() and fillSugar() to adjust quantities.
  - getCoffee() returning a fixed coffee amount (0.15f).
- SingletoneClass main():
  - Calls CoffeeMachine.getInstance() three times into m1, m2, m3.
  - Prints references, confirming they point to the same object.
  - Verifies identity with `==` operator, printing "Same".

WHY this matters:
- Demonstrates the **Singleton Pattern**, ensuring only one instance of a class exists across the JVM.
- Useful when:
  - A single shared resource is needed (e.g., database connection, logging system, configuration manager).
  - Object creation is costly, and reusing one instance is efficient.
- Shows how private constructors and static methods enforce singleton behavior.

HOW it works:
1. First call to getInstance() → my is null, new CoffeeMachine is created and stored in my.
2. Subsequent calls → my already holds the instance, so the same object is returned.
3. Printing references proves all variables point to the same memory location.
4. Identity check (==) confirms all references refer to the same singleton object.

Tips and gotchas:
- This implementation is **not thread-safe**. Multiple threads calling getInstance() simultaneously could create multiple objects.
  - Fix: synchronize getInstance() or use double-checked locking with volatile, or enum-based singleton.
- Singleton can make testing harder if not carefully managed; consider dependency injection for flexibility.
- Class names should follow conventions: SingletoneClass → SingletonClass, coffeQty → coffeeQty.
- Returning a fixed getCoffee() value is just illustrative; real logic could reduce coffeeQty, waterQty, etc.

Use-cases / analogies:
- Coffee machine analogy: only one machine available in a kitchen, everyone uses the same one.
- Logging: one logger instance shared across application modules.
- Configuration: one global configuration object accessed everywhere.

Short key: java-oop singleton-pattern private-constructor static-factory shared-instance.

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

Author: Someshdiwan

Section16StaticFinal/src/SingletoneClass.java

@@ -1,41 +1,37 @@
-//Pending solve it onces again.
-
-class CoffeeMachine
-{
+class CoffeeMachine {
     private float coffeQty;
     private float milkQty;
     private float waterQty;
     private float sugarQty;
 
     static private CoffeeMachine my=null;
 
-    private CoffeeMachine()
-    {
+    private CoffeeMachine() {
         coffeQty=1;
         milkQty=1;
         waterQty=1;
         sugarQty=1;
     }
 
-    public void fillWater(float qty)
-    {
+    public void fillWater(float qty) {
         waterQty=qty;
     }
-    public void fillSugar(float qty)
-    {
+
+    public void fillSugar(float qty) {
         sugarQty=qty;
     }
-    public float getCoffee()
-    {
+
+    public float getCoffee() {
         return 0.15f;
     }
-    static CoffeeMachine getInstance()
-    {
+
+    static CoffeeMachine getInstance() {
         if(my==null)
             my=new CoffeeMachine();
         return my;
     }
 }
+
 public class SingletoneClass {
     public static void main(String[] args) {
         CoffeeMachine m1=CoffeeMachine.getInstance();
@@ -45,6 +41,5 @@ public static void main(String[] args) {
         System.out.println(m1+" "+m2+" "+m3);
         if(m1==m2 && m1==m3)
             System.out.println("Same");
-
     }
 }