feat: Add Product and Customer classes with encapsulation and interactive input

WHAT the code does:
Defines product class with private fields:
- itemNo, name, price, and quantity.
- Provides overloaded constructors for partial and full initialization.
- Getters and setters provide controlled access.

Defines Customer class with private fields:
- custID, name, address, and phone number.
- Constructor initializes ID and name, with defaults for address and phone.
- Getters and setters allow controlled updates.

Defines ProductAndCostomer with main():
- Uses Scanner to take user input for product and customer details.
- Creates product and customer objects with the given values.
- Displays stored details for both objects.

WHY this matters:
Demonstrates encapsulation by making fields private and exposing only controlled access.
Shows constructor overloading to support multiple initialization scenarios.
Illustrates interactive object creation using Scanner for input.
Models a simple real-world relationship: customer purchasing a product.

HOW it works:
User is prompted for product details (item number, name, price, quantity).
A product object is created using the full constructor.
User is prompted for customer details (ID, name, address, phone).
A customer object is created and populated via constructor and setters.
Program prints product and customer details via getters.

Tips and gotchas:
Class names should follow Java conventions: Product (instead of product) and ProductAndCustomer (instead of ProductAndCostomer).
Validation logic is missing: setters currently allow negative price/quantity; adding checks would improve robustness.
Default values in Customer (empty string for address and phone) are fine for placeholders but could be null-checked in practice.
toString() overrides for Product and Customer would simplify printing object state.

Use-cases:
Educational example of constructors, encapsulation, and object composition.
Simple model of product–customer interaction for retail or billing systems.
Foundation for extending into order management or inventory tracking applications.

Short key: class-product customer encapsulation constructor-overloading scanner-input.

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

Author: Someshdiwan

Section11ObjectOrientedProgramming/src/ProductAndCostomer.java

@@ -1,84 +1,81 @@
 /*
 Product: itemno, name, price, qty 4 properties here.
-you should write properties method get and set method you have write down methods.
+you should write properties method get and set method you have writedown methods.
 and now ypu have to write constructors.
 Customer: custID, name, address, phno.
-What is data type of itemNo, this is alpha numeric and this sholud be string or int. Ex: A25 , this should be string.
+What is a data type of itemNo, this is an alphanumeric, and this should be string or int. Ex: A25, this should be string.
 you also takr long data type.
-price double and name is string and Quantity in shop may be short or long byte what ever you required decide data type proper.
+
+price double and name is string and Quantity in shop may be short or long byte whatever you required decide data type proper.
 Properties methods: you have to write get method. String getItemNo, String getName, like this...
-setMethod: set method means it change the propertie of item can i have setItemNo. setItemNO(String itemNo) we can not change itemNo everytime.
-setItemNo should not be allowd. it should be in constructer.
-setName also not allowd.
-setPrice allowd beacuse it changes frequently you write down those
-setQuanttity allowd. it changes frequently.
 
-Now Constructer, if you have construction product class it must take itemnumber. there is no non parameterized constucter.
-Product(String itemNo , String name)
+setMethod: set method means it change the propertie of item can i have setItemNo.
+setItemNO(String itemNo) we can not change itemNo everytime.
+setItemNo should not be allowd. it should be in constructer.
+setName also aren't allowed.
+setPrice allowed because it changes frequently you write down those
+setQuantity allowed. it changes frequently.
 
+Now Constructor, if you have construction product class it must take itemnumber. there is no non-parameterized constructor.
+Product (String itemNo , String name)
 
 Class Customer: CustomerID, name, address, PhoneNumber, now decide data type, properties method and constructers.
 like what we do in product class.
-CustomerId: String is ok, name string , phoneNo: String because +91 we added , all thing are Strings.
-Propertie methods are: all of them are get method and set method can not modified we gave at the time of registration and we cant change after that.
+CustomerId: String is ok, name string , phoneNo: String because +91 we added, all things are Strings.
+Propertie methods are: all of them are get method and set method cannot modify we gave it at the time of registration, and we can't change after that.
 we change only addresss, so setAddress. setPhoneNumber.
-Constructers; Customer(c.id, name) we cannot create customer id without mentioning his customerid and name. so there is no parameterized constructer here.
+Constructers; Customer(c.id, name) we cannot create a customer id without mentioning his customerid and name.
+so there is no parameterized constructor here.
 
 This is a Java program that defines two classes,
 Product and Customer, and then takes input from the user to create objects of these classes and display their details.*/
 
 import java.util.Scanner;
 
-class product
-{
+class product {
     private String itemNo;
     private String name;
     private double price;
     private short qty;
 
-    public product(String itemNo)
-    {
+    public product(String itemNo) {
        this.itemNo = itemNo;
     }
 
-    public product(String itemNo, String name)
-    {
+    public product(String itemNo, String name) {
         this.itemNo = itemNo;
         this.name = name;
     }
-    public product(String itemNo, String name, double price, short qty)
-    {
+
+    public product(String itemNo, String name, double price, short qty) {
         this.itemNo=itemNo;
         this.name=name;
         setPrice(price);
         setQuantity(qty);
     }
+
     public String getItemNo(){return  itemNo;}
     public String getName(){return name;}
     public double getPrice(){return price;}
     public short getQuantity(){return qty;}
 
-    public void setPrice(double price)
-    {
+    public void setPrice(double price) {
         this.price=price;
     }
-    public void setQuantity(short qty)
-    {
+
+    public void setQuantity(short qty) {
         this.qty=qty;
     }
 }
 
 //Now for Customer
-
-class Customer
-{
+class Customer {
     private String custID;
     private String name;
     private String address;
     private String phno;
 
-    public Customer(String custId, String name)
-    {
+    public Customer(String custId, String name) {
         this.custID = custId;  // ✅ Corrected assignment
         this.name = name;      // ✅ Corrected assignment
         this.address = "";     // Default value (can be changed later)
@@ -93,16 +90,14 @@ public Customer(String custId, String name)
     public void setAddress(String address){
         this.address=address;
     }
-    public void setPhno(String phno)
-    {
+
+    public void setPhno(String phno) {
         this.phno=phno;
     }
 }
 
-public class ProductAndCostomer
-{
-    public static void main(String[] args)
-    {
+public class ProductAndCostomer {
+    public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
 
         // Taking product details
@@ -176,7 +171,7 @@ Only price and qty can be modified after creation (via setter methods).
 Only address and phno can be changed after registration.
 
 Constructors:
-Customer(String custID, String name) → Requires a customer ID and name.
+Customer (String custID, String name) → Requires a customer ID and name.
 ProductAndCustomer (Main Class)
 
 Uses Scanner to take user input.
@@ -190,4 +185,4 @@ Prompts the user for customer details (custID, name, address, phno).
 ✅ Shows constructors for object initialization.
 ✅ Implements user input handling with Scanner.
 ✅ Practices object-oriented programming (OOP) in Java.
-*/
+*/