feat: Add CylinderTestDemo with constructors, setters, getters, and geometry methods

WHAT the code does:
Defines a CylinderTestDemo class with private fields radius and height.
Implements multiple constructors:
- Default constructor: initializes radius and height to 1.
- Parameterized constructor: initializes radius and height with given values.
Provides getter methods getRadius() and getHeight().
Provides setter methods setRadius(int r), setHeight(int h), and setDimensions(int h, int r) with validation to prevent negative values.
Adds geometry methods:
- lidArea(): area of the circular lid (πr²).
- perimeter(): circumference of the circle (2πr).
- drumArea(): total surface area of the cylinder (2πr² + 2πrh).
- volume(): volume of the cylinder (πr²h).
Defines Cylinder with main():
- Creates a CylinderTestDemo object.
- Sets radius and height using setters and setDimensions().
- Prints all computed values and validates getters.
- Uses printf with %.2f for formatted numerical output.

WHY this matters:
Demonstrates encapsulation with private fields and controlled access via getters and setters.
Shows constructor overloading for flexible initialization of objects.
Encodes validation logic in setters, preventing invalid states (negative radius or height).
Illustrates real-world object modeling by combining data (radius, height) with relevant operations (area, volume).
Highlights string concatenation vs arithmetic addition nuances in Java when mixing with System.out.printf.

HOW it works:
Default constructor initializes radius = height = 1.
Setters enforce non-negative values (if negative, assign 0).
lidArea computes πr², perimeter computes 2πr, drumArea adds lid areas and lateral surface, volume multiplies base area by height.
Main method demonstrates usage and outputs calculated geometry values.

Tips and gotchas:
The method setDimensions(int h, int r) flips the conventional (r,h) order, which may cause confusion.
Surface area formula in drumArea is correct but could be made clearer with explicit terms.
Public setters allow changing state freely; in immutable designs, prefer constructor-only initialization.
Naming consistency (e.g., drumArea vs surfaceArea) would improve clarity.
Add constructor chaining (this(...)) to reduce duplication across constructors.

Use-cases:
Educational demonstration of constructor overloading, encapsulation, and object behavior.
Practical geometric utility for calculating cylinder properties.
Foundation for extending into engineering or graphics applications.

Short key: class-cylindertestdemo constructors encapsulation geometry-methods.

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

Author: Someshdiwan

Section11ObjectOrientedProgramming/src/Cylinder.java

@@ -1,75 +1,73 @@
 /*
 Properties: Radius and Height.(get and set methods)
-What are the methods you write getRadius() and getHight().
-What are the set methods we Required. First is setRadius(Parameters and make sure it is not a negative. double r) and setHeight(double h).
+What are the methods you write getRadius() and getHeight().
+What are the set methods we Required.
+First is setRadius(Parameters and make sure it is not a negative. double r) and setHeight(double h).
 Read and writable properties.
 setDimensions(double r, double h)
 now lets write constructors name is same as a class name
 Cylinder() first constructors and no parameters and second is Cylinder(int r) h=1 and Cylinder(int r, int h)
 */
 
-class CylinderTestDemo
-{
+class CylinderTestDemo {
     private int radius;
     private int height;
 
-    public CylinderTestDemo()
-    {
+    public CylinderTestDemo() {
         radius=height=1;
     }
 
-    public CylinderTestDemo(int r, int h)
-    {
+    public CylinderTestDemo(int r, int h) {
         radius=r;
         height=h;
     }
-    public int getHeight()
-    {
+
+    public int getHeight() {
         return height;
     }
-    public int getRadius()
-    {
+
+    public int getRadius() {
         return radius;
     }
-    public void setHeight(int h)
-    {
+
+    public void setHeight(int h) {
         if(h>=0)
             height=h;
         else
             height=0;
     }
-    public void setRadius(int r)
-    {
+
+    public void setRadius(int r) {
         if(r>=0)
             radius=r;
         else
             radius=0;
     }
-    public void setDimensions(int h, int r)
-    {
+
+    public void setDimensions(int h, int r) {
         height=h;
         radius=r;
     }
-    public double lidArea()
-    {
+
+    public double lidArea() {
         return Math.PI*radius*radius;
     }
-    public double perimeter()
-    {
+
+    public double perimeter() {
         return 2*Math.PI*radius;
     }
-    public double drumArea()
-    {
+
+    public double drumArea() {
         return 2*lidArea()+perimeter()*height;
     }
-    public double volume()
-    {
+
+    public double volume() {
         return lidArea()*height;
     }
 }
+
 public class Cylinder {
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) {
         CylinderTestDemo c = new CylinderTestDemo();
         c.setHeight(10);
         c.setRadius(7);
@@ -85,7 +83,8 @@ public static void main(String[] args)
         System.out.printf("Total Above are: %.2f%n",
                 c.lidArea() + c.perimeter() + c.drumArea() + c.volume() + c.getHeight() + c.getRadius());
         /*
-        Java evaluates expressions from left to right. Since "Total Above are " is a String, all subsequent additions (+) are treated as string concatenation rather than arithmetic addition.
+        Java evaluates expressions from left to right. Since "Total Above are " is a String,
+        all subsequent additions (+) are treated as string concatenation rather than arithmetic addition.
         Instead of adding the numerical values together, Java concatenates them as strings.
         Java first evaluates the arithmetic sum inside the parentheses and then concatenates the result with the string.
         %.2f ensures two decimal places.
@@ -111,4 +110,4 @@ public static void main(String[] args)
 height = 1
 
 This ensures that the object has meaningful default values before any setter methods are called.
-*/
+*/