Function Fundamentals Revision

Welcome to the first course in the "Functional Programming in Java" path! Get ready to revisit the basics of functions, and then dive into exciting topics like functional interfaces, the powerful Streams API, and more—it's going to be a great journey toward mastering functional programming in Java!

Functions, or methods, are the building blocks of any Java program. They encapsulate code, making it reusable, modular, and easier to manage. In this section, we'll revisit the foundational concepts of functions in Java, including their syntax, arguments, and return types. We'll also delve into the details of essential keywords used in function declarations.

Every Java application must have a main method, which serves as the entry point for the program. It is where the program starts executing.

public class Main {

    public static void main(String[] args) {
        // Your code here
    }
}

Let’s break down the main method:

• public: This keyword specifies that the method is accessible from outside its defining class. It is the most open access level in Java.
• static: Indicates that the method belongs to the class, not instances of the class. This means you can call the method without creating an object of the class.
• void: The return type, indicating that the method does not return any value. If the function were to return something, this keyword would be replaced with the appropriate type (e.g., int, String).
• main: This is the name of the method, and it is a special method recognized by the Java runtime as the entry point of the application.
• String[] args: This is an array of String arguments passed to the main method. It allows for command-line arguments to be passed to the program.

public class Main {

    // A basic function in Java
    public static void sayHello() {
        System.out.println("Hello, world!");
    }

    public static void main(String[] args) {
        // Calling the function
        sayHello(); // Output: Hello, world!
    }
}

In Java, a function is defined by specifying its return type, name, and any parameters it may take. Let’s break down the sayHello function:

• Return Type: The type of value the function returns. void means the function does not return any value.
• Function Name: The name of the function, which in this example is sayHello.
• Parameters: Input values the function can accept. This function doesn't take any parameters.
• Function Body: The block of code that runs when the function is called. Here, it prints "Hello, world!" to the console.

public class Main {

    // Function that takes an argument
    public static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        // Calling the function with an argument
        greet("Alice"); // Output: Hello, Alice!
    }
}

Arguments allow you to pass data into functions. The greet function takes a String argument named name:

• Parameter: name is the parameter that the function accepts.
• Function Overloading: Functions can also be overloaded by defining multiple functions with the same name but different parameter lists. This will be explored in a later unit.

The function can generate different outputs depending on the argument passed when it is called.

public class Main {

    // Function that returns a value
    public static int add(int a, int b) {
        return a + b;
    }

    // Function that doesn't return a value
    public static void displaySum(int sum) {
        System.out.println("Sum: " + sum);
    }

    public static void main(String[] args) {
        // Calling the function and storing the result
        int sum = add(5, 10);
        // Calling the function that doesn't return a value
        displaySum(sum); // Output: Sum: 15
    }
}

Functions can return values, which can then be used elsewhere in your code. In the add function, the return type is int, meaning the function must return an integer value. Here are a few important points:

• Return Type Matching: The return type declared in the method signature (int in this case) must match the type of the value returned by the method.
• Return Statements: Use the return keyword to return a value from a function. Functions without a return value use the void keyword, and they do not require a return statement.
• Compilation Requirement: If a function’s return type is not void, it must return a value on every possible execution path. Failing to do so will result in a compilation error.

Mastering the basics of Java functions is crucial for several reasons, including:

1. Code Organization: Functions help you structure your code into manageable, logical sections.
2. Reusability: Functions can be called multiple times, reducing code duplication.
3. Maintainability: Well-organized functions make your code easier to read, understand, and modify.

With these basics in place, you are well-prepared to delve into more advanced Java programming concepts. Understanding functions is the foundation upon which much of your future Java knowledge will be built. Let's get ready to put these concepts into practice!