feat: Implement detailed demonstration of Upcasting with method overriding in Java

This commit adds a complete Java program that demonstrates the concept of upcasting
(child to parent class type conversion), object access limitations, and method overriding.

Key components:
- Defined a parent class `Animals` with a `name` property and a method `nature()`
- Created a child class `Fish` extending `Animals`, adding a `color` property
  and overriding the `nature()` method to reflect aquatic behavior
- In `main`, demonstrated:
  - Upcasting: `Animals a = new Fish();` — a `Fish` object referenced by a `Animals` type
  - Access limitation: `a` can only access fields and methods defined in `Animals`, not `Fish`-specific ones
  - Method overriding: `a.nature()` calls the overridden method in `Fish` due to runtime polymorphism
  - Direct child object usage: `Fish f = new Fish();` can access both `name` and `color`, showing full class access
- Included explanatory comments throughout the code to clarify:
  - Differences between upcasting and direct object reference
  - Compile-time restrictions and runtime behavior
  - Use cases for overriding and polymorphic method invocation

This example provides a foundational understanding of inheritance, typecasting,
method overriding, and polymorphism in Java — crucial concepts for object-oriented design.

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

Author: Someshdiwan

Section5OperatorExpression/src/Upcasting.java

@@ -1,7 +1,9 @@
 /*
 Upcasting: Upcasting is the typecasting of a child object to a parent object.
 
-Upcasting can be done implicitly.Upcasting gives us the flexibility to access the parent class members,
+Upcasting can be done implicitly.
+
+Upcasting gives us the flexibility to access the parent class members,
 but it is not possible to access all the child class members using this feature.
 
 Instead of all the members, we can access some specified members of the child class.
@@ -10,24 +12,20 @@ but it is not possible to access all the child class members using this feature.
 */
 
 class Animals {
-
     String name;
 
-   /*A method to print the nature of the class*/
-    void nature()
-    {
+    /*A method to print the nature of the class*/
+    void nature() {
         System.out.println("Animal");
     }
 }
 
 class Fish extends Animals {
-
     String color;
-    /*Overriding the method to print the nature of the class*/
 
+    /*Overriding the method to print the nature of the class*/
     @Override
-    void nature()
-    {
+    void nature() {
         System.out.println("Aquatic Animal");
     }
 }
@@ -41,48 +39,50 @@ public static void main(String[] args) {
         Here, the Fish object is being assigned to an Animals reference.
         Since Fish is a subclass of Animals, this is perfectly valid.
         */
+
         // Parent p = new Child();
         Animals a = new Fish();
-/*
+
+        /*
         The object 'a' has access to
         only the parent's properties.
         That is, the colour property
         cannot be accessed from 'a'
-*/
-
+        */
 
         a.name = "GoldFish";
-/*
+
+         /*
          This statement throws
          a compile-time error
          a.color = "Orange";
          Creating an object to represent
          Child c = new Child();
-*/
-
+         */
 
         Fish f = new Fish();
-/*
+        /*
          The object 'f' has access to
          all the parent's properties
          along with the child's properties.
          That is, the colour property can
          also be accessed from 'f'
-*/
+         */
 
         f.name = "Whale";
         f.color = "Blue";
         /*Printing the 'a' properties*/
         System.out.println("Object a");
         System.out.println("Name: " + a.name);
 
-/*
+
+        /*
         This statement will not work
         System.out.println("Fish1 Color" +a.color);
 
         Access to child class - overridden method
         using parent reference
-*/
+        */
         a.nature();
 
         /*Printing the 'f' properties*/
@@ -102,4 +102,4 @@ Animals a is a reference variable that can point to an object of type Animals or
 
 So, the whole statement is demonstrating upcasting (assigning a subclass object to a superclass reference) and
 polymorphism, where the reference type (Animals) is more general, and the actual object created (Fish) is more specific.
-*/
+*/