feat: Add MethodsCC class with squareAndCube method

WHAT the code does:
- Defines a `MethodsCC` class with a static method `squareAndCube(int x)`.
- `squareAndCube()` prints the square and cube of the input integer.
- `main()` calls this method for values `2`, `3`, and `4`.

WHY this matters:
- Demonstrates **methods with parameters** for reusable logic.
- Reinforces arithmetic operations and function abstraction.
- Shows how the same method can be reused for multiple inputs.

HOW it works:
1. `squareAndCube(2)` → prints `4` and `8`.
2. `squareAndCube(3)` → prints `9` and `27`.
3. `squareAndCube(4)` → prints `16` and `64`.

Tips & gotchas:
- Current implementation prints directly — could be enhanced to return results for reuse.
- Works fine for small integers; for large values, consider `long` or `BigInteger` to avoid overflow.
- Method naming (`squareAndCube`) is descriptive and follows good practice.

Use-cases:
- Educational demo for **methods with arguments**.
- Useful in teaching function reusability in math-related problems.
- Can be extended into a math utility library.
- Good exercise for beginners in Java.

Short key: class-methodscc-square-cube.

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

Author: Someshdiwan

Section10Methods/PracticeProblems/src/MethodsCC.java

@@ -1,12 +1,9 @@
-class MethodsCC
-{
-    public static void squareAndCube(int x)
-    {
+class MethodsCC {
+    public static void squareAndCube(int x) {
         System.out.println(x * x);
         System.out.println(x * x * x);
     }
-    public static void main (String[] args)
-    {
+    public static void main (String[] args) {
         int a = 2;
         int b = 3;
         int c = 4;
@@ -15,32 +12,40 @@ public static void main (String[] args)
         squareAndCube(c);
     }
 }
+
 /* 
 why we use x in System.out.println.
 
-In the method squareAndCube(int x), the x is a parameter. It acts as a placeholder for the value that you pass to the method when you call it.
+In the method squareAndCube(int x), the x is a parameter.
+It acts as a placeholder for the value that you pass to the method when you call it.
 
 How it works:
 When you call squareAndCube(a), the value of a (which is 2) is passed to the method.
 Inside the method, x takes the value of a, so x = 2.
 Now, when you write System.out.println(x * x), it calculates 2 * 2 and prints 4.
 Similarly, System.out.println(x * x * x) calculates 2 * 2 * 2 and prints 8.
+
 Why use x?
-x is a variable that holds the value passed to the method. It allows the method to work with any value you pass, making the method reusable.
+x is a variable that holds the value passed to the method.
+It allows the method to work with any value you pass, making the method reusable.
+
 For example, when you call squareAndCube(b), x becomes 3, and when you call squareAndCube(c), x becomes 4.
-Key Takeaway:
-x is just a placeholder for the value you pass to the method. It makes the method flexible and reusable for different inputs.
-*/
 
+Key Takeaway:
+x is just a placeholder for the value you pass to the method.
+It makes the method flexible and reusable for different inputs.
 
-/*
 Methods improve code in several ways:
 
-Reusability: You can write a method once and call it multiple times, avoiding code duplication. For example, in the given problem, squareAndCube is called three times instead of writing the same logic three times.
+Reusability: You can write a method once and call it multiple times, avoiding code duplication.
+For example, in the given problem, squareAndCube is called three times instead of writing the same logic three times.
+Modularity: Methods break down complex tasks into smaller, manageable parts.
+This makes the code easier to understand, debug, and maintain.
 
-Modularity: Methods break down complex tasks into smaller, manageable parts. This makes the code easier to understand, debug, and maintain.
+Readability: By giving meaningful names to methods, your code becomes more readable.
 
-Readability: By giving meaningful names to methods, your code becomes more readable. For example, squareAndCube clearly indicates what the method does.
+For example, squareAndCube clearly indicates what the method does.
 
-Maintainability: If you need to change the logic, you only need to update it in one place (the method), rather than in multiple places.
-*/
+Maintainability: If you need to change the logic, you only need to update it in one place (the method),
+rather than in multiple places.
+*/