Methods & Arrays: Reusable Code and Collections of Data

As programs grow, two problems appear. First, you find yourself copying the same lines again and again—methods solve that by letting you name a block of code and reuse it. Second, you need to handle many values at once, not just single variables—arrays solve that by storing a fixed-size collection under one name. Together these are the workhorses of real code. In a test framework, a method might be “log in with this username and password”, called from a hundred tests; an array might hold every expected product name you need to verify. This module builds both skills from scratch with testing-flavoured examples.

What is a method?

A method is a named block of code that performs a task. You have already used methods—System.out.println is one—and you have written one: main. Now you will write your own. Defining a method means you can run that code any time by calling its name, instead of retyping it. This is the DRY principle: Don’t Repeat Yourself. Here is the anatomy:

public static void greet() {
    System.out.println("Welcome to QALaunch!");
}

• public — an access modifier (who can call it); more on this in Module 4.
• static — means the method belongs to the class itself, so you can call it without creating an object (covered below).
• void — the return type. void means “returns nothing”.
• greet — the method name, followed by () for its parameters (here, none).

You call it simply by writing its name:

public static void main(String[] args) {
    greet();          // prints: Welcome to QALaunch!
    greet();          // call it as many times as you like
}

Parameters and return types

Methods become powerful when they accept parameters (inputs) and produce a return value (output). Parameters are declared in the parentheses; the return type replaces void and you hand back a value with the return keyword.

// Takes two int inputs, returns their sum as an int
public static int add(int a, int b) {
    return a + b;
}

// Takes a name, returns a greeting String
public static String buildGreeting(String name) {
    return "Hello, " + name + "!";
}

public static void main(String[] args) {
    int sum = add(3, 4);                 // sum is now 7
    String msg = buildGreeting("Priya"); // msg is "Hello, Priya!"
    System.out.println(sum);
    System.out.println(msg);
}

The values you pass in (3, 4, "Priya") are called arguments. They are matched to the parameters by position and must match the declared types. Once a method returns a value, you can store it, print it, or pass it straight into another method—exactly how a test helper like getPageTitle() would feed its result into an assertion.

Method overloading

Java lets you define several methods with the same name as long as their parameter lists differ—different number of parameters, or different types. This is overloading. Java picks the right one based on the arguments you pass.

public static int add(int a, int b) {
    return a + b;
}

public static int add(int a, int b, int c) {   // three ints
    return a + b + c;
}

public static double add(double a, double b) {  // two doubles
    return a + b;
}

// Java chooses the matching version automatically:
add(2, 3);        // calls the first  -> 5
add(2, 3, 4);     // calls the second -> 9
add(2.5, 3.5);    // calls the third  -> 6.0

Overloading is why System.out.println happily accepts a String, an int, or a boolean—there are many overloaded versions behind that one name. Note: the return type alone cannot distinguish overloads; the parameters must differ.

Variable scope

Scope is the region of code where a variable exists and can be used. A variable declared inside a method (or a loop, or an if block) is a local variable—it lives only within the braces where it was declared and vanishes when that block ends.

public static void demo() {
    int x = 10;              // x exists only inside demo()
    if (x > 5) {
        int y = 20;          // y exists only inside this if-block
        System.out.println(x + y);
    }
    // System.out.println(y);  // ERROR: y is out of scope here
}
// System.out.println(x);      // ERROR: x is out of scope here too

Keeping variables in the smallest scope that works is good practice: it prevents accidental reuse and makes code easier to reason about. If two methods each declare their own x, they are completely separate—no interference.

Static vs instance methods (a first look)

You have seen static on every method so far. Here is the short version, to be expanded in Module 4. A static method belongs to the class and is called on the class name, with no object needed: Math.max(3, 7). An instance method belongs to an object (an individual thing created from a class) and is called on that object: myString.toUpperCase()—you need an actual String object to call it on.

// static: called on the class, no object required
int bigger = Math.max(3, 7);          // 7

// instance: called on an object
String name = "priya";
String upper = name.toUpperCase();     // "PRIYA" - needs the object 'name'

Rule of thumb for now: utility helpers that just take inputs and return a result are often static; behaviour tied to a specific object’s data is an instance method. Module 4 makes this concrete.

Varargs: a variable number of arguments

Sometimes you want a method to accept any number of arguments. Varargs (variable arguments), written with ..., let you do that. Inside the method, the arguments arrive as an array.

public static int sumAll(int... numbers) {   // accepts zero or more ints
    int total = 0;
    for (int n : numbers) {                  // numbers behaves like an array
        total += n;
    }
    return total;
}

sumAll();              // 0
sumAll(5);             // 5
sumAll(1, 2, 3, 4);    // 10

A varargs parameter must be the last parameter in the list. You will see this pattern in testing utilities—for example a method that takes any number of expected values to check against.

Arrays: storing many values

An array is a fixed-size, ordered collection of values of the same type, stored under one name. Instead of test1, test2, test3, you keep one array scores. Each slot has a numbered position called an index, and—crucially—indexes start at 0. An array of 5 elements has indexes 0, 1, 2, 3, 4.

// Declare and initialise with known values:
int[] scores = {90, 85, 72, 95, 60};

// Access by index:
System.out.println(scores[0]);   // 90  (the first element)
System.out.println(scores[4]);   // 60  (the last element)

// Change an element:
scores[2] = 78;                  // the third slot is now 78

// How many elements? Use .length (a field, not a method)
System.out.println(scores.length);   // 5

You can also create an empty array of a given size and fill it later. Numeric arrays default to 0, booleans to false, and object arrays (like String[]) to null.

String[] browsers = new String[3];   // three empty slots (all null)
browsers[0] = "chrome";
browsers[1] = "firefox";
browsers[2] = "edge";

Iterating over arrays

To process every element, you loop. There are two idiomatic ways. The classic for loop uses the index—use it when you need the position number:

int[] scores = {90, 85, 72, 95, 60};
for (int i = 0; i < scores.length; i++) {
    System.out.println("Score at index " + i + " is " + scores[i]);
}

The enhanced for loop (also called for-each) reads each element directly and is cleaner when you do not need the index:

for (int score : scores) {          // read as "for each score in scores"
    System.out.println(score);
}

In Selenium you will write for (WebElement row : rows) constantly—this is that exact pattern, looping over every element the browser found.

Common array tasks

A few patterns come up again and again: summing, finding a maximum, and searching.

int[] scores = {90, 85, 72, 95, 60};

int total = 0;
int max = scores[0];
boolean found95 = false;

for (int score : scores) {
    total += score;                 // running sum
    if (score > max) max = score;   // track the largest
    if (score == 95) found95 = true; // search
}

double average = (double) total / scores.length;   // cast to avoid integer division
System.out.println("Total: " + total);     // 402
System.out.println("Max: " + max);         // 95
System.out.println("Average: " + average); // 80.4
System.out.println("Has a 95: " + found95); // true

Note the cast to double when computing the average—without it, 402 / 5 would use integer division and give 80, losing the .4.

Two-dimensional arrays

A 2D array is an array of arrays—a grid with rows and columns. It is perfect for tables, which you meet constantly in web testing. You index with two numbers: grid[row][column].

// A 3-row, 2-column grid of test data (username, password pairs)
String[][] credentials = {
    {"alice", "pass1"},
    {"bob",   "pass2"},
    {"carol", "pass3"}
};

System.out.println(credentials[0][0]);   // "alice"
System.out.println(credentials[2][1]);   // "pass3"

// Iterate over every cell with nested loops:
for (int row = 0; row < credentials.length; row++) {
    for (int col = 0; col < credentials[row].length; col++) {
        System.out.print(credentials[row][col] + " ");
    }
    System.out.println();   // new line after each row
}

That credentials grid is a sneak peek at data-driven testing: one test body, many rows of input—exactly how you would run the same login test against several accounts.

The Arrays utility class

Java ships a helper class, java.util.Arrays, full of static methods for common array work. Import it with import java.util.Arrays; and you get sorting, searching, printing, and comparing for free.

import java.util.Arrays;

int[] scores = {90, 85, 72, 95, 60};

// Print an array readably (plain println on an array prints gibberish):
System.out.println(Arrays.toString(scores));   // [90, 85, 72, 95, 60]

// Sort in place (ascending):
Arrays.sort(scores);
System.out.println(Arrays.toString(scores));   // [60, 72, 85, 90, 95]

// Fill every slot with a value:
int[] zeros = new int[3];
Arrays.fill(zeros, 7);
System.out.println(Arrays.toString(zeros));    // [7, 7, 7]

// Compare two arrays for equal contents:
System.out.println(Arrays.equals(new int[]{1,2}, new int[]{1,2}));  // true

static void bump(int[] data) {
    data[0] = 99;                 // affects the caller's array
}

int[] nums = {1, 2, 3};
bump(nums);
System.out.println(nums[0]);      // 99, not 1