2.5 Calling a Non-void Method - Top Study Guide

Calling a non-void method in Java involves invoking a method that returns a value, which can be of any data type other than void. Such methods perform operations and return a result that can be used directly in expressions or stored in variables for later use.

Defining a Non-void Method

A non-void method declaration includes a return type, which indicates the type of value the method will return. The method must end with a return statement that provides a value of the specified type.

java

public class Calculator {


// A non-void method that returns an integer

    public int add(int num1, int num2) {

        int sum = num1 + num2;

        return sum; // Return the result


// A non-void method that returns a double

    public double divide(int numerator, int denominator) {

        if (denominator == 0) {

            System.out.println("Error: Division by zero");

            return 0; // Return a default value

        return (double) numerator / denominator;

Calling a Non-void Method

To call a non-void method, you typically need an instance of the class (for non-static methods) or use the class name itself (for static methods). The method’s return value can be assigned to a variable, used to control a decision structure, or printed out directly.

Creating an Instance and Calling Methods

java

public class TestCalculator {

    public static void main(String[] args) {

        // Create an instance of the Calculator class

        Calculator myCalc = new Calculator();


// Calling the add method and storing its return value

        int additionResult = myCalc.add(10, 5);

        System.out.println("The sum is: " + additionResult);


// Directly using the divide method's return value in a print statement

        System.out.println("The division result is: " + myCalc.divide(20, 4));


// Attempting to divide by zero, which handles the error within the method

myCalc.divide(20, 0);

// Outputs "Error: Division by zero"

Key Points to Remember

Non-void methods must include a return statement that returns a value matching the declared return type of the method.
The method’s return value can be used in various ways: it can be assigned to a variable, used in expressions, or output directly.
It’s good practice for methods that perform operations with the potential for errors (like division) to include error handling, such as returning a default value or throwing an exception.
For non-static methods, you need an instance of the class to call the method. For static methods, call them using the class name.

Understanding how to define and call non-void methods is fundamental to Java programming, as it allows for the creation of reusable, modular code that can perform operations, return results, and facilitate the flow of data within an application.

Frequently Asked Questions: Calling Non-Static and Non-Void Methods in Java

How do you call a Non-Static Method in Java (whether it's void or returns a value)? +

Non-static methods (also called instance methods) belong to **objects** (instances) of a class, not the class itself. Therefore, to call a non-static method, you must first **create an object** of the class that contains the method. Once you have an object, you call the method using the **object's name** followed by the dot (`.`) operator and the method name, including parentheses `()`.

public class MyClass {
    // Non-static void method
    public void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

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

    public static void main(String[] args) {
        // To call non-static methods, create an object of MyClass
        MyClass myObject = new MyClass();

        // Call the non-static void method
        myObject.greet("Alice"); // Output: Hello, Alice!

        // Call the non-static non-void method and use its return value
        int sum = myObject.add(5, 3);
        System.out.println("Sum: " + sum); // Output: Sum: 8
    }
}

How do you call a method in Java that is Non-Void (returns a value)? +

A non-void method is one that has a return type specified in its signature (e.g., `int`, `String`, `double`, `boolean`, or an object type). When you call such a method, it computes a value and sends it back to the place where it was called.

**Calling and Using the Return Value:** Since the method produces a value, you typically need to **store** that value in a variable (whose data type matches the method's return type) or **use** it directly in an expression or as an argument for another method call.
**Method Call Syntax:** The call syntax itself is the same as any other method call (using the object name for non-static or class name for static), but you must handle the returned value.

public class Calculator {
    // Static method that returns an int
    public static int multiply(int x, int y) {
        return x * y;
    }

    public static void main(String[] args) {
        // Call the static non-void method and store the result
        int product = Calculator.multiply(4, 6);
        System.out.println("Product: " + product); // Output: Product: 24

        // Call the method and use the result directly in an expression
        System.out.println("Calculation result: " + (Calculator.multiply(10, 2) - 5)); // Output: Calculation result: 15
    }
}