feat: Add Person class with epitaph method for lifespan calculation

WHAT the code does:
- Defines a `Person` class with attributes:
  - `Name`
  - `YearBorn`
  - `YearDeceased`
- Constructor initializes these attributes.
- `epitaph()` method calculates lifespan as `YearDeceased - YearBorn` and prints a formatted message.
- `main()` creates a `Person` object (`Mary`, 1932–1999) and calls `epitaph()`.

WHY this matters:
- Demonstrates **basic class design** with attributes, constructor, and instance methods.
- Shows how to compute derived information (lifespan) from stored fields.
- Useful educational example for encapsulation and object instantiation in Java.

HOW it works:
1. Constructor assigns values when `new Person()` is called.
2. `epitaph()` subtracts `YearBorn` from `YearDeceased`.
3. Prints → `"Mary lived to an age of 67"`.

Tips & gotchas:
- Assumes `YearDeceased > YearBorn`; negative or zero values would be illogical.
- Does not handle still-living persons (e.g., `YearDeceased = 0` or `null`).
- Encapsulation could be improved with getters/setters.
- Use consistent variable naming → prefer lowercase fields (`yearBorn`, `yearDeceased`) for Java convention.

Use-cases:
- Biographical applications.
- Educational examples for **constructors and methods**.
- Foundation for genealogy/family-tree programs.
- Demonstration of computing lifespan dynamically.

Short key: class-person-epitaph-lifespan.

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

Author: Someshdiwan

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

@@ -1,27 +1,25 @@
-public class Person
-{
-    //attributes of every Person object
-    private int yearBorn;
-    private int yearDeceased;
-    private String name;
+public class Person {
+    //attributes of every Person object.
+    // attributes of every Person object
+    private int YearBorn;
+    private int YearDeceased;
+    private String Name;
 
-    //constructor//
-    public Person(String named, int born, int died)
-    {
-        name = named;
-        yearBorn = born;
-        yearDeceased = died;
+    // constructor
+    public Person(String Name, int YearBorn, int YearDeceased) {
+        this.Name = Name;
+        this.YearBorn = YearBorn;
+        this.YearDeceased = YearDeceased;
     }
 
-    //instance (object) method//
-    public void epitaph()
-    {
-        /* Print <name> lived to an age of <age> */
+    // instance method
+    public void epitaph() {
+        int age = YearDeceased - YearBorn;
+        System.out.println(Name + " lived to an age of " + age);
     }
 
-    public static void main(String[] args)
-    {
-        Person grandma = new Person("Mary", 1932, 1999);
-        grandma.epitaph(); //apply method to object (yes, in this case, grandma is considered an object)
+    public static void main(String[] args) {
+        Person person = new Person("Mary", 1932, 1999);
+        person.epitaph();
     }
-}
+}