Java Arrays

An array in Java is a container object that holds a fixed number of values of a single type. It is a way to store multiple values in a single variable, rather than declaring separate variables for each value. Arrays are useful for handling collections of data efficiently.

1. Declaring Arrays

To declare an array, specify the type of its elements followed by square brackets. For example:

int[] numbers;

Here, numbers is a variable that can hold an array of int values.

2. Creating Arrays

Arrays must be initialized after they are declared. You can create an array using the new keyword:

numbers = new int[5];

This creates an array of integers with a length of 5. All elements are initialized to the default value for integers, which is 0.

3. Initializing Arrays

You can also initialize an array at the time of declaration:

int[] numbers = {1, 2, 3, 4, 5};

This creates an array with the specified values. The array length is automatically determined based on the number of elements.

4. Accessing Array Elements

Array elements are accessed using an index, which starts from 0. For example:

int firstNumber = numbers[0]; // Accesses the first element
int secondNumber = numbers[1]; // Accesses the second element

Attempting to access an index outside the bounds of the array will result in an ArrayIndexOutOfBoundsException.

5. Array Length

The length of an array can be obtained using the length property:

int length = numbers.length;

This returns the number of elements in the array.

6. Multidimensional Arrays

Java supports multidimensional arrays, such as 2D arrays. They are essentially arrays of arrays:

int[][] matrix = new int[3][3];

This creates a 3x3 matrix. You can initialize and access elements in a multidimensional array as follows:

matrix[0][0] = 1;
matrix[1][1] = 2;
matrix[2][2] = 3;

System.out.println(matrix[0][0]); // Outputs 1

7. Enhanced For Loop

The enhanced for loop (or "for-each" loop) can be used to iterate over arrays:

for (int number : numbers) {
    System.out.println(number);
}

This loop will print each element of the numbers array.

8. Example

Here's a complete example demonstrating array usage:

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

This example creates an array of integers, then uses an enhanced for loop to print each value.

Java Methods

Methods in Java are blocks of code designed to perform specific tasks. They help in organizing and reusing code. Methods allow you to encapsulate functionality, making your code modular and easier to maintain.

1. Defining a Method

A method is defined using the following syntax:

returnType methodName(parameters) {
    // method body
    return value; // if returnType is not void
}

Here, returnType specifies the type of value the method returns. If the method does not return a value, use void. methodName is the name of the method, and parameters are the inputs to the method.

2. Example of a Method

Here’s a simple example of a method that calculates the square of an integer:

public class MathOperations {
    public static int square(int number) {
        return number * number;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println("The square is " + result);
    }
}

In this example, the square method takes an integer number as a parameter and returns its square. The main method calls square and prints the result.

3. Method Overloading

Java supports method overloading, where multiple methods can have the same name but different parameters. This allows you to define several versions of a method to handle different types or numbers of inputs:

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

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

In this example, the add method is overloaded to handle both int and double types.

4. Method Parameters

Methods can accept parameters, which are values passed into the method. Parameters are defined within the parentheses in the method signature:

public void printMessage(String message) {
    System.out.println(message);
}

In this example, the printMessage method takes a String parameter message and prints it.

5. Return Statement

The return statement is used to exit a method and optionally return a value. If the method's return type is void, it does not return a value:

public int multiply(int a, int b) {
    return a * b;
}

This method multiplies two integers and returns the result.

6. Recursive Methods

Methods can call themselves, which is known as recursion. Recursive methods must have a base case to terminate the recursion:

public int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    else {
        return n * factorial(n - 1);
    }
}

This factorial method calculates the factorial of a number using recursion.

7. Method Scope

Variables defined within a method are local to that method and cannot be accessed from outside it. Similarly, methods defined in a class can only be accessed if they are declared public or through an object if they are private:

public class Example {
    public void showMessage() {
        String message = "Hello, World!";
        System.out.println(message);
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.showMessage();
    }
}

In this example, the message variable is local to the showMessage method and is not accessible outside it.

Java Method Overriding, Overloading, and Recursion

In Java, methods are fundamental for code organization and reusability. Java supports method overriding, overloading, and recursion, each serving different purposes in object-oriented programming.

1. Method Overloading

Method overloading allows a class to have more than one method with the same name, but with different parameters. The method signature (name and parameter list) must be unique.

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

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

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

In this example, the add method is overloaded with different parameter lists.

2. Method Overriding

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The method in the subclass must have the same name, return type, and parameters as the method in the superclass. The overriding method can provide a specialized behavior for the method.

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // Outputs "Dog barks"
    }
}

Here, the makeSound method in Dog overrides the method in Animal. When called, it prints "Dog barks" instead of "Animal makes a sound".

3. Method Recursion

Recursion is a technique where a method calls itself in order to solve a problem. A recursive method must have a base case to stop the recursion, otherwise, it can lead to infinite recursion and stack overflow errors.

public class Factorial {
    public int calculateFactorial(int n) {
        if (n == 0) {
            return 1;
        }
        else {
            return n * calculateFactorial(n - 1);
        }
    }

    public static void main(String[] args) {
        Factorial fact = new Factorial();
        System.out.println(fact.calculateFactorial(5)); // Outputs 120
    }
}

This example calculates the factorial of a number using recursion. The base case is when n is 0, and the recursive case multiplies n by the factorial of n - 1.

4. Example Combining Overloading and Overriding

Here's a complete example demonstrating both method overloading and overriding:

class Printer {
    public void print(String text) {
        System.out.println(text);
    }

    public void print(int number) {
        System.out.println(number);
    }
}

class ColorPrinter extends Printer {
    @Override
    public void print(String text) {
        System.out.println("Color Printer: " + text);
    }
}

public class Main {
    public static void main(String[] args) {
        Printer myPrinter = new Printer();
        myPrinter.print("Hello");
        myPrinter.print(123);

        Printer myColorPrinter = new ColorPrinter();
        myColorPrinter.print("Hello");
    }
}

In this example, the print method is overloaded in the Printer class and overridden in the ColorPrinter class. The ColorPrinter class provides a specialized implementation of the print method for String parameters.