feat: Add basic constructor demo with static methods in class Constructor [constructor-basics-static]

🔑 Key: constructor-basics-static
🧠 Logic:
- Defined a class named `Constructor` to demonstrate:
  • ✅ A **no-argument constructor** — prints a message when object is instantiated.
  • ✅ Two **static methods** (`puton()` and `takeOFF()`) representing actions on a Shirt.

- Instantiating an object (`new Constructor()`) triggers the constructor automatically.
- Static method `puton()` is called using object (though ideally should be `Constructor.puton()`).

📌 Concepts Demonstrated:
- 🧱 **Constructor Rules**:
   • Same name as class.
   • No return type, not even `void`.
   • Used to initialize objects at creation.

- 🧼 **Static Methods**:
   • Belong to class, not to instances.
   • Can be called without creating object (e.g., `Constructor.puton()`).

🧪 Notes:
- Calling `takeOFF()` was commented out but can be used similarly.
- The constructor acts like an **object initializer**, even if no values are passed or set.

🧠 Analogy:
- Think of constructor as a “birth certificate” that sets up an object during its birth.

📎 Educational Value:
- Great minimal template for explaining object lifecycle and class-vs-instance behaviors.

Signed-off-by: Somesh diwan <[email protected]>

Author: Someshdiwan

Section10Methods/Methods 2.O/src/Constructor.java

@@ -1,35 +1,35 @@
-//Remember - A constructor name should be the same as class name
-//and must not have a return type(void).
-//Think of constructors as the birth certificate of an object. When you create an object in Java, it needs to be initialized with some initial values or properties.
-//Constructors are used to initialize these properties and prepare the object for use.
-//Remember - A constructor name should be the same as class name and must not have a return type(void).
-
-//If no constructor is defined in a class, Java provides a default no-argument constructor automatically.
-//This default constructor initializes the object but doesn't set any properties, leaving instance variables with their default values (e.g., null for objects, 0 for integers, false for booleans, etc.).
 public class Constructor {
-
     private String color;
     private char size;
 
-    //Remember - A constructor name should be the same as class name.
-    Constructor()
-    {
+    //Remember - A constructor name should be the same as a class name.
+    Constructor() {
         System.out.println("Inside constructor");
     }
 
-    public static void puton()
-    {
+    public static void puton() {
         System.out.println("Shirt is On!");
     }
 
-    public static void takeOFF()
-    {
+    public static void takeOFF() {
         System.out.println("Shirt is off!");
     }
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) {
         Constructor c = new Constructor();
         c.puton();
         //c.takeOFF();
     }
-}
+}
+
+/*
+Remember - A constructor name should be the same as a class name and must not have a return type(void).
+Think of constructors as the birth certificate of an object.
+When you create an object in Java, it needs to be initialized with some initial values or properties.
+Constructors are used to initialize these properties and prepare the object for use.
+
+Remember - A constructor name should be the same as a class name and must not have a return type(void).
+
+If no constructor is defined in a class, Java provides a default no-argument constructor automatically.
+This default constructor initializes the object but doesn't set any properties, leaving instance variables with their
+default values (e.g., null for objects, 0 for integers, false for booleans, etc.).
+*/