Update Abstraction.md

Author: Fahd-Bin-Ashfaq

week_11/Abstraction.md

@@ -1,41 +1,48 @@
 ### Abstraction 
 
-Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object. It simplifies interactions by focusing on what an object does rather than how it does it.
+Abstraction is the concept of hiding complex implementation details and showing only the necessary system features. We use abstract classes to define what must be done, not how.
 
-For example, when you use a smartphone, you don’t need to understand the internal circuits and software. You simply use the phone's interface to make calls, send messages, or browse the internet. The intricate details are hidden, allowing you to focus on the phone’s features.
+For example, you don’t need to understand the internal circuits and software when you use a smartphone. You use the phone's interface to make calls, send messages, or browse the internet. The internal details are hidden, allowing you to focus on the phone’s features.
 
 ### Two Ways of Abstraction
 
-1. **Abstract Class**:
-   - An abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It can include abstract methods (methods without implementation) that must be implemented by subclasses.
-   - **Python Example**:
-
-     ```python
-     from abc import ABC, abstractmethod
-
-     class Vehicle(ABC):
-         @abstractmethod
-         def start(self):
-             pass
-         
-         @abstractmethod
-         def stop(self):
-             pass
-
-     class Car(Vehicle):
-         def start(self):
-             print("Car is starting")
-
-         def stop(self):
-             print("Car is stopping")
-
-     my_car = Car()
-     my_car.start()  # Output: Car is starting
-     my_car.stop()   # Output: Car is stopping
+1. **Abstract Class**  
+   - An abstract class is a class you **cannot use directly** to create objects.  
+   - It is made to be used by other classes (called child classes).
+   - It can have **abstract methods** — these are like empty functions with no code inside.
+   - The child class must **write the real code** for those methods.
+
+   **🧠 Python Example:**
+
+   ```python
+   from abc import ABC, abstractmethod
+
+   # Abstract class
+   class Vehicle(ABC):
+       @abstractmethod
+       def start(self):
+           pass
+       
+       @abstractmethod
+       def stop(self):
+           pass
+
+   # Child class
+   class Car(Vehicle):
+       def start(self):
+           print("Car is starting")
+
+       def stop(self):
+           print("Car is stopping")
+
+   my_car = Car()
+   my_car.start()  # Output: Car is starting
+   my_car.stop()   # Output: Car is stopping
+opping
      ```
 
 2. **Abstract Method**:
-   - An abstract method is a method defined in an abstract class without an implementation. Subclasses that inherit from the abstract class must provide their own implementation of these methods.
+   - An abstract method is a method that is defined in an abstract class without implementation details. Subclasses that inherit from the abstract class provide the implementation of abstract method.
    - **Python Example**:
 
      ```python
@@ -58,6 +65,3 @@ For example, when you use a smartphone, you don’t need to understand the inter
      print(my_rectangle.area())  # Output: 20
      ```
 
-In these examples:
-- The **abstract class** `Vehicle` defines methods `start` and `stop` without implementing them. The subclass `Car` must provide implementations for these methods.
-- The **abstract method** `area` in the `Shape` class is implemented by the `Rectangle` subclass, which provides the specific logic for calculating the area of a rectangle.