Important: Methods are used to describe reusable code and to simplify programming.

int sum = 0;
for (int i = 1; i <= 10; i++)
    sum += i;
System.out.println("Sum from 1 to 10 is " + sum);

sum = 0;
for (int i = 20; i <= 37; i++)
    sum += i;
System.out.println("Sum from 20 to 37 is " + sum);

sum = 0;
for (int i = 35; i <= 49; i++)
    sum += i;
System.out.println("Sum from 35 to 49 is " + sum);

 1 public static int sum(int i1, int i2) {
 2   int result = 0;
 3   for (int i = i1; i <= i2; i++)
 4     result += i;
 5
 6   return result;
 7 }
 8
 9 public static void main(String[] args) {
10   System.out.println("Sum from 1 to 10 is " + sum(1, 10));
11   System.out.println("Sum from 20 to 37 is " + sum(20, 37));
12   System.out.println("Sum from 35 to 49 is " + sum(35, 49));
13 }

Important: A method is a collection of statements grouped together to perform an operation.

Important: A method definition consists of the method name, parameters, return type, and method body.

/*
What the method does
*/
modifiers returnType methodName(list of parameters) {
    // method body
}

public static int max(int num1, int num2) {
    int result;
    if (num1 > num2) {
        result = num1;
    } else {
        result = num2;
    }
    return result;
}

Important: Each parameter in the method header must have a separate declaration. For example, the header max(int num1, int num2) is valid, but max(int num1, num2) is invalid.

int larger = max(3, 4);

System.out.println(max(3, 4));

System.out.println("Welcome!");

Important: Return type is used to indicate what type the method will return. Use void if the method will not return a value, or any supported data type.

 public class TestMax {
   /**
    * Main method
    */
   public static void main(String[] args) {
     int i, j, k;
     i = 5;
     j = 2;
     k = max(i, j); // invoke max method
     System.out.println("The maximum of " + i +
       " and " + j + " is " + k);
   }

   /**
    * Returns the maximum of two numbers
    */
   public static int max(int num1, int num2) {
     int result;

     if (num1 > num2)
       result = num1;
     else
       result = num2;

     return result; // return result
   }
 }

Important: A return statement is required for a value-returning method. The method on the left is logically correct, but it has a compilation error because the Java compiler thinks that this method might not return a value.

Important: Methods enable code sharing and reuse. The max method can be invoked from any class besides TestMax. If you create a new class, you can invoke the max method using ClassName.methodName() (i.e., TestMax.max()).

int z = max(2, 5);
System.out.println(z);

public class L10Max {
    public static int max(int num1, int num2) {
        int result;
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }

    public static void main(String[] args) {
        int z = max(2, 5);
        System.out.println(z);
    }
}

public class TestVoidMethod {
    public static void main(String[] args) {
        System.out.print("The grade is ");
        printGrade(78.5);

        System.out.print("The grade is ");
        printGrade(59.5);
    }

    public static void printGrade(double score) {
        if (score >= 90.0) {
            System.out.println('A');
        } else if (score >= 80.0) {
            System.out.println('B');
        } else if (score >= 70.0) {
            System.out.println('C');
        } else if (score >= 60.0) {
            System.out.println('D');
        } else {
            System.out.println('F');
        }
    }
}

public class TestReturnGradeMethod {
    public static void main(String[] args) {
        System.out.print("The grade is " + getGrade(78.5));
        System.out.print("\nThe grade is " + getGrade(59.5));
    }

    public static char getGrade(double score) {
        if (score >= 90.0)
            return 'A';
        else if (score >= 80.0)
            return 'B';
        else if (score >= 70.0)
            return 'C';
        else if (score >= 60.0)
            return 'D';
        else
            return 'F';
    }
}

Important: A void method does not require a return statement, but it may be used to terminate the method and return to the method's caller. The syntax is simply:

return;

This is not often done in void methods, but it is sometimes useful for circumventing the normal flow of control. For example, the following code fragment has a return statement to terminate the method when the score is invalid:

public static void printGrade(double score) {
    if (score < 0 || score > 100) {
        System.out.println("Invalid score");
        return;
    }
    if (score >= 90.0) {
        System.out.println('A');
    }
    else if (score >= 80.0) {
        System.out.println('B');
    }
    else if (score >= 70.0) {
        System.out.println('C');
    }
    else if (score >= 60.0) {
        System.out.println('D');
    }
    else {
        System.out.println('F');
    }
}

public class Main {
    public static void main(String[] args) {
        int a = plus2(); // get value from method
        System.out.println(a); // prints 3
    }

    static int plus2() {
        int a = 1;
        a += 2;
        return a;
    }
}

public static void nPrintln(String message, int n) {
    for (int i = 0; i < n; i++)
        System.out.println(message);
}

Caution: The arguments must match the parameters in order, number, and compatible type, as defined in the method signature. Compatible type means that you can pass an argument to a parameter without explicit casting, such as passing an argument of type int to a parameter of type double.

public class Increment {
    public static void main(String[] args) {
        int x = 1;
        System.out.println("Before the call, x is " + x);
        increment(x);
        System.out.println("After the call, x is " + x);
    }

    public static void increment(int n) {
        n++;
        System.out.println("Inside the method, n is " + n);
    }
}

public class TestPassByValue {
    /** Main method */
    public static void main(String[] args) {
        int num1 = 1;
        int num2 = 2;

        System.out.println("Before invoking the swap method, num1 is "
            + num1 + " and num2 is " + num2);

        // Invoke the swap method to attempt to swap two variables
        swap(num1, num2);

        System.out.println("After invoking the swap method, num1 is "
            + num1 + " and num2 is " + num2);
    }

    /** Swap two variables */
    public static void swap(int n1, int n2) {
        System.out.println("\tInside the swap method");
        System.out.println("\t\tBefore swapping, n1 is " + n1
            + " and n2 is " + n2);

        // Swap n1 with n2
        int temp = n1;
        n1 = n2;
        n2 = temp;

        System.out.println("\t\tAfter swapping, n1 is " + n1
            + " and n2 is " + n2);
    }
}

Diagram: Memory locations for num1, num2, n1, and n2 showing pass-by-value.

Important: Method overloading allows you to define multiple methods with the same name if their parameter lists are different.

public static double max(double num1, double num2) {
    if (num1 > num2)
        return num1;
    else
        return num2;
}

public class TestMethodOverloading {
    /** Main method */
    public static void main(String[] args) {
        // Invoke the max method with int parameters
        System.out.println("The maximum of 3 and 4 is "
            + max(3, 4));
        // Invoke the max method with double parameters
        System.out.println("The maximum of 3.0 and 5.4 is "
            + max(3.0, 5.4));
        // Invoke the max method with three double parameters
        System.out.println("The maximum of 3.0, 5.4, and 10.14 is "
            + max(3.0, 5.4, 10.14));
    }

    /** Return the max of two int values */
    public static int max(int num1, int num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    /** Return the max of two double values */
    public static double max(double num1, double num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    /** Return the max of three double values */
    public static double max(double num1, double num2, double num3) {
        return max(max(num1, num2), num3);
    }
}

Important: Overloaded methods must differ in at least the parameter list. You cannot overload methods based on different return types. You cannot overload methods based on different modifiers.

Important: Sometimes there are two or more possible matches for an invocation of a method, but the compiler cannot determine the most specific match. This is referred to as ambiguous invocation. Ambiguous invocation causes a compilation error. Consider the program AmbiguousOverloading:

public class AmbiguousOverloading {
    public static void main(String[] args) {
        System.out.println(max(1, 2));
    }

    public static double max(int num1, double num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }

    public static double max(double num1, int num2) {
        if (num1 > num2)
            return num1;
        else
            return num2;
    }
}

Important: The scope of a variable is the part of the program where the variable can be referenced.

Important: A common mistake is to declare a variable inside a for loop and then attempt to use it outside the loop. As shown in the following code, variable i is declared inside the for loop, and an attempt to access it outside the loop causes a syntax error.

for (int i = 0; i < 10; i++) {
    // ...
}
System.out.println(i); // Causes a syntax error

Lab 1: Argument and Overloading

To do: Create a Sum() method that takes two integer arguments and sums them. The method returns no value (which is why you have to use void).

Note: We need to use the static keyword in the method signature because the main function is static and we cannot call a non-static method from a static method.

File name: L10Lab1.java

Expected output:

Algorithm:

1. Create a new Java file named L10Lab1.java.
2. Import the Scanner class for input.
3. In the main function, request the user to input two numbers:

   import java.util.Scanner;
   ...
   System.out.println("Please enter two numbers");
   
   int a = 0, b = 0;
   Scanner scanner = new Scanner(System.in);
   a = scanner.nextInt();
   b = scanner.nextInt();
   ...

4. Place your cursor after the closing curly brace of the static void main(String[] args) function and press Enter. We are doing this because you don’t want to place methods/functions inside another function.
5. Declare a new method called Sum() that will be used to add values passed into it:

   ...
   static void sum(int first, int second) {
       int sum = first + second;
       System.out.printf("The sum of %d and %d is: %d%n", first, second, sum);
   }
   ...

   The method doesn’t return any value to the main program, which is why we have to use the void keyword. The method calculates the sum of two values passed in.
6. Now we can call this method from within the main function. Enter the following code within the curly braces of main():

   public static void main(String[] args) {
       ...
       sum(a, b);  // method call
   }

7. Run the program (e.g., press F5 in your IDE).
8. The function sum() we’ve created doesn’t return a value. We will now modify that method so that it returns the result to the calling method (to the main method from where it was called).
9. Comment the code of the sum() function using the shortcut key [CTRL]+K+C (or appropriate comment style in your IDE):

   //static void sum(int first, int second)
   //{
   //    int sum = first + second;
   //    System.out.printf("The sum of %d and %d is: %d%n", first, second, sum);
   //}

10. Place your cursor after these comments and enter the following code:

    ...
    static int sum(int first, int second) {
        int sum = first + second;
        return sum;
    }
    ...

    The method returns an integer value, which is why we use int in the signature (static int sum(...)). Notice that the parameters’ names we have specified here in the method may not match the names of the arguments we have passed in. They become local variables within the scope of this method.
11. Then we need to modify the code in main(). We have to change the way to call the method. Declare an integer variable to receive the return value. Print out the result to the console window.

    ...
    public static void main(String[] args) {
        ...
        int result = sum(a, b);
        System.out.println("The sum of " + a + " and " + b + " is " + result);
    }
    ...

12. Run the application again and check the output. Both outputs should be the same.

Overloading the method (function):

Overloading Methods means having a method with the same name but different signatures.

1. Let’s now overload our sum() method. To do it we will create two additional methods with the same names.
2. Place your cursor after the sum() method code. First, create a method that accepts three integers by entering the following code:

   static int sum(int first, int second, int third) {
       int sum = first + second + third;
       return sum;
   }

   This method uses the same name as the sum() method that takes two integers, but the parameters here indicate the method is expecting three integers as arguments. The compiler knows which method to call based on the number of arguments passed in.
3. Next, enter the following code that will create a sum() method that accepts two doubles as arguments:

   ...
   static double sum(double first, double second) {
       double result = first + second;
       return result;
   }
   ...

   This method uses the same name as the sum() method that takes two integers, but the parameters here indicate the method is expecting two doubles as arguments. The compiler knows which method to call based on the arguments data types.
4. Finally, modify the code in main() that calls the methods:

   ...
   int result = sum(a, b);
   System.out.println("Calling Sum() with two arguments, result is: " + result);
   
   int result3 = sum(10, 50, 80);
   System.out.println("Calling Sum() with three arguments, result is: " + result3);
   
   double dblResult = sum(20.5, 30.6);
   System.out.println("Calling Sum() that takes doubles result in: " + dblResult);
   ...

5. Run the application again and check the output. You should see the correct summed values displayed for each call of the three different methods. Even though they are all named sum, the compiler works out the correct method to call based on the method signature. That is how method overloading works.
6. Upload the file into the Moodle system.

Lab 2: Building an Exponent Function

To do: Create a getPow() method that takes two integer arguments: a base number and a power number. The method returns the result of taking a base number to a power number (an exponent).

Note 1: We need to use static in the method signature because the main function is static and we cannot call a non-static method from a static method.

Note 2: The function returns an integer value, which is why you have to use int in the signature of the function: static int getPow(int baseNum, int powNum) {…}

Expected output:

File name: L10Lab2.java

Algorithm:

1. Create a new Java file named L10Lab2.java.
2. Import the Scanner class for input.
3. After a closing curly brace of the main function, type the signature of the getPow function:

   static int getPow(int baseNum, int powNum) {
       ...
   }

   The function expects two integer numbers – baseNum argument and powNum argument. Inside the function, we’re going to take the baseNum to the power of powNum.
4. Declare a variable result to return its value from the function as a result.

   int result = 1;
   ...
   return result;

5. Inside the function, create a for loop to keep multiplying the result variable by baseNum powNum times:

   for (int i = 0; i < powNum; i++) {
       result = result * baseNum;
   }

   The first time we go through the loop we always have 1 * baseNum and store the result in the result variable. The second time we have baseNum * baseNum. The third – baseNum * baseNum * baseNum, etc. We repeat it each iteration.
6. Within the main function, call the method:

   getPow(2, 4);

7. Run the application and check the output.
8. Instead of the particular numbers (2 and 4), prompt the user to input two numbers and change the code for calling the function:

   System.out.println("Please enter two numbers – a base number and a power number: ");
   
   int a = scanner.nextInt();
   int b = scanner.nextInt();
   
   System.out.println(getPow(a, b));
   
   scanner.close();

9. Run the application again and check the output.
10. Save and upload the file into the Moodle system.

Lab 3: Public and Private Modifiers. Calculating Product of Numbers Divisible by 3

To do: Create a project where a method calculates the product of all integers divisible by 3 in the range from A to B (inclusive). Call the method from the main function.

Expected output:

Project name: Lesson_10Lab3

File name: L10Lab3.java

Step-by-Step Algorithm:

1. Step 1. Creating the project and class file
   • Create a new project in your IDE (e.g., IntelliJ IDEA or Eclipse) named Lesson_10Lab3.
   • Add a new Java class file named L10Lab3.java.
2. Step 2. Creating a separate class for calculations (Class1.java)

   Create a separate class Class1.java where the method for calculating the product will be implemented.

   Code for Class1.java:

   public class Class1 {
       // Public static method to calculate the product of numbers divisible by 3
       public static int calculateProduct(int a, int b) {
           int product = 1; // Initialize variable to store product
   
           // Loop to iterate from a to b
           for (int i = a; i <= b; i++) {
               if (i % 3 == 0) { // Check if number is divisible by 3
                   product *= i; // Multiply product by current number
               }
           }
           return product; // Return the result
       }
   }

   Explanation:

   • public – the method is accessible from other classes.
   • static – the method can be called without creating an object of the class.
   • int – the method returns an integer (the product).
   • The for loop iterates from a to b.
   • The condition i % 3 == 0 checks divisibility by 3.
   • product *= i multiplies the current product by i.

3. Step 3. Main program (L10Lab3.java)

   In the file L10Lab3.java, implement data input and call the method from Class1.

   Code for L10Lab3.java:

   import java.util.Scanner;
   
   public class L10Lab3 {
       public static void main(String[] args) {
           Scanner scanner = new Scanner(System.in);
   
           // Ask the user to enter two numbers
           System.out.println("Enter two integers:");
           int a = scanner.nextInt(); // First number (lower bound)
           int b = scanner.nextInt(); // Second number (upper bound)
   
           // Call the method from Class1 and save the result
           int result = Class1.calculateProduct(a, b);
   
           // Output the result
           System.out.println("The result is " + result);
       }
   }

   Explanation:

   • Import Scanner for console input.
   • Create a Scanner object to read input.
   • Prompt for and read two integers (a and b).
   • Call the calculateProduct method from Class1, passing a and b.
   • Print the result.

4. Step 4. Running and debugging
   • Save both files (Class1.java and L10Lab3.java).
   • Run the program (Run or F5 in your IDE).
   • Enter two numbers, for example:
     • First number: 3
     • Second number: 9
   • The program will output: The result is 162 (since 3 × 6 × 9 = 162).

Summary:

• Class1.java contains the calculateProduct method with public static modifiers, accessible from other classes.
• L10Lab3.java is the main program that prompts the user for a range and calls the method from Class1.
• The program correctly calculates the product of numbers divisible by 3 in the given range.

Lab 4: Calculating Product Cost

To do: Write a program that calculates the total cost of a product. Data used for calculation: unit cost in rubles, quantity of units, inclusion/exclusion of VAT (20%) in the product cost. If the quantity of units is greater than or equal to 10, a 5% discount applies.

Hint: Use overloaded methods to obtain the total cost.

Expected output:

For testing, let's input unit cost = 5, quantity = 10. When prompted to include VAT, enter an answer not in the suggested options. The same prompt reappears because we entered an invalid value. Enter "do not include VAT". The calculated cost is 47.5.

Check another execution path: input unit cost = 10, quantity = 5. Include VAT. The calculated cost is 60.

Project name: Lesson_10Lab4

File name: L10Lab4.java

Step-by-Step Algorithm:

1. Create a new Java file named L10Lab4.java.
2. Import the required classes: import java.util.Scanner;
3. Define the class L10Lab4 with a main method.
4. Inside main, create a Scanner object for input.

   import java.util.Scanner;
   
   public class L10Lab4 {
       public static void main(String[] args) {
           // ...
       }
   }

5. First, inside the class, declare constants:
   • 5% discount;
   • VAT rate 20%.

   static final int DISCOUNT_FIVE = 5; // discount in %
   static final double VALUE_ADDED_TAX = 20; // VAT rate in %

6. Inside the main() method, declare variables needed for calculations; three of them are for user input data, the fourth is for the calculation result.

   double unitCost; // unit cost of the product
   int amount; // quantity of the product
   String includeVatResponse; // include VAT in cost
   double fullCost; // total cost

7. First, get the unit cost in rubles from the console.

   Scanner input = new Scanner(System.in);
   // Get unit cost
   System.out.print("Enter unit cost of the product: ");
   unitCost = input.nextDouble();

8. Next, get the quantity from the console.

   // Get quantity
   System.out.print("Enter quantity of the product: ");
   amount = input.nextInt();

9. Get the answer to whether to include VAT.

   Use a do-while loop to validate input.

   // Get answer on VAT inclusion until a correct value is entered
   do {
       System.out.print("Include VAT in cost (y/n): ");
       includeVatResponse = input.next();
   } while (!"y".equalsIgnoreCase(includeVatResponse)
           && !"n".equalsIgnoreCase(includeVatResponse));

10. Then add a new algorithm step as a comment.

    // Get total cost based on the obtained data

11. Organize the new algorithm step using a two-way if-else selection structure, each branch of which contains another nested if-else structure. Thus we get four alternative execution paths.

    if ("y".equalsIgnoreCase(includeVatResponse)) {
        // include VAT in cost
        if (amount >= 10) {
            // apply discount
    
        } else {
            // no discount
    
        }
    } else {
        // do not include VAT in cost
        if (amount >= 10) {
            // apply discount
    
        } else {
            // no discount
    
        }
    }

12. Implement a method to get the total cost without VAT and without discount.

    /**
     * Get total cost without VAT and without discount
     */
    public static double getFullCost(double unitCost, int amount) {
        return unitCost * amount;
    }

13. For getting cost without VAT but with discount, use method overloading and create a method with the same name, adding discount as a parameter.

    /**
     * Get total cost without VAT but with discount
     */
    public static double getFullCost(double unitCost, int amount, int discount) {
        double priceWithDiscount = unitCost * (1 - discount / 100.0) * amount; // price with discount
        return Math.round(priceWithDiscount * 100) / 100.0; // round to kopecks
    }

14. Again, use method overloading for calculating cost including VAT but without discount.

    /**
     * Get total cost including VAT but without discount
     */
    public static double getFullCost(double unitCost, int amount, double valueAddedTax) {
        double priceWithoutVAT = unitCost * amount; // price without VAT
        double priceWithVAT = priceWithoutVAT * (1 + valueAddedTax / 100); // price with VAT
        return Math.round(priceWithVAT * 100) / 100.0; // round to kopecks
    }

15. And again overload the method for calculating cost including VAT and with discount.

    /**
     * Get total cost including VAT and with discount
     */
    public static double getFullCost(double unitCost, int amount, int discount, double valueAddedTax) {
        double priceWithoutVAT = unitCost * (1 - discount / 100.0) * amount; // price with discount
        double priceWithVAT = priceWithoutVAT * (1 + valueAddedTax / 100); // price with VAT
        return Math.round(priceWithVAT * 100) / 100.0; // round to kopecks
    }

16. We now have four methods with the same name but different parameter sets. Insert the appropriate overloaded method into the four branches of our cost calculation cycle.

    if ("y".equalsIgnoreCase(includeVatResponse)) {
        // include VAT in cost
        if (amount >= 10) {
            // apply discount
            fullCost = getFullCost(unitCost, amount, DISCOUNT_FIVE, VALUE_ADDED_TAX);
        } else {
            // no discount
            fullCost = getFullCost(unitCost, amount, VALUE_ADDED_TAX);
        }
    } else {
        // do not include VAT in cost
        if (amount >= 10) {
            // apply discount
            fullCost = getFullCost(unitCost, amount, DISCOUNT_FIVE);
        } else {
            // no discount
            fullCost = getFullCost(unitCost, amount);
        }
    }

17. Print the calculated cost to the console.

    // Output the result of total cost calculation
    System.out.println("Total cost of the product = " + fullCost);

18. Run the finished program.

Assignment 1: GCD of Two Numbers

To do: Write a program that computes and displays the greatest common divisor (GCD) of two numbers.

Task Analysis

Input data:

• int n1; // first number
• int n2; // second number

Program variables:

• int k; // counter

Output data:

• int gcd; // GCD

Method:

public static int find_gcd(int n1, int n2) {
    int gcd, k;
    gcd = 1; // GCD initialized to 1
    k = 1; // prospective GCD value
    ...
}

Algorithm with refinements:

1. Get the first number.
2. Get the second number.
3. Compute the GCD of the two numbers.
   1. Let GCD be 1.
   2. While both numbers are greater than or equal to the prospective GCD.
      1. If both numbers are divisible without remainder by the prospective GCD, then update GCD.
      2. Increment the prospective GCD by 1.
4. Display the GCD of the two numbers.

File name: L10Assign1.java

Extra Task 1

To do: Create a FloorCubicRoot function that finds the largest integer that does not exceed the cubic root of the specified number (Math.pow, Math.floor).

Note: You can calculate the cubic root of the number x in the wolframalpha service using the query x^(1/3), for example: 15.625^(1/3) (the answer is 2.5).

Expected output:

File name: L10ExTask1.java

Extra Task 2

To do: A real number A and an integer N (≥ 0) are entered. Create a function SumOfSeq() which finds the sum of:

1 + A + A² + A³ + ... + Aⁿ

Note 1: Within a function, there has to be the only loop.

Note 2: Do not use standard pow function for the degree, accumulate the values of degrees using a loop.

Expected output:

File name: L10ExTask2.java