First Code School

Methods in Java

by · Published · Updated

Java stands as a highly acclaimed programming language on a global scale, renowned for its capacity to define and employ methods effectively. Methods, encompassing blocks of code, grant the ability to invoke them from various program sections, facilitating logic encapsulation and enhancing code organization and comprehensibility.

By utilizing methods, developers can create modular code structures, resulting in improved code readability and maintainability. In this article, we’ll cover the basics of Java methods, their importance in programming, and how you can use them to build better software.

Importance of Methods in Java Programming:

Methods play a crucial role in Java programming as they enable code reuse and promote modularity in your programs. By employing methods, you can avoid repetitive code by defining it once and invoking the method whenever the code needs to be used again. This eliminates the need to duplicate the same code multiple times, leading to more efficient and concise programming. This approach saves valuable time and enhances the efficiency of your code. Methods also make your code more readable and easier to understand, as they encapsulate complex logic and allow you to break down your code into smaller, more manageable pieces.

What Will be Covered in this Java Methods:

In this article, we’ll cover the basics of Java methods, including how to define and call them, as well as how to use parameters and return values. Additionally, we will explore effective strategies for utilizing methods in your code and present practical examples of how methods can be applied in real-life situations.

By following these best practices, one can enhance the organization and readability of your code while maximizing the benefits of using methods.

What are Java Methods?

Java methods are a set of instructions that can be executed repeatedly in a Java program. Methods allow developers to organize code into reusable and modular blocks, which can be called from anywhere in the program.

Syntax of defining a method:

access_modifier return_type method_name (parameter1, parameter2, ..., parameterN) {
    // method body
    return return_value;  }

Defining and Calling Methods:

To create a method in Java, you specify an access modifier, followed by the method’s return type (if applicable), the method name, and any parameters it requires. For instance, consider this straightforward method that accepts two integers as parameters and returns their sum:

public int add(int x, int y) {
return x + y;
}

To invoke a method in Java, you utilize the method name along with any necessary parameters it expects. For example, to call the “add” method defined above, you would use the following code:

int result = add(3, 4);

This would set the “result” variable to 7, which is the sum of 3 and 4.

Parameters and Return Values:

Methods in Java have the ability to accept parameters, which are values passed to the method during its invocation. For example, the “add” method defined above takes two parameters, “x” and “y”. Methods can also have return values, which are values that the method returns when it’s finished executing. For example, the “add” method returns the sum of its two parameters.

Parameters and return types:

In Java, methods can have zero or more parameters, which are variables passed to the method during its invocation. Additionally, methods can have a return type, which specifies the data type of the value that the method returns.

Example of a simple method:

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

In the above example, add is a method that takes two integer parameters, a and b. The method computes the sum of a and b and returns the result.
To call the add method from another part of the program, we simply use its name and pass in the required parameters:

int result = add(5, 3); // result is 8

Methods with Parameters

Java methods can accept parameters which are values passed to the method for it to work with.

  • Parameters help in writing more flexible and reusable code.
  • To pass parameters to a method, we declare them within the parentheses when defining the method. There can be a single parameter or multiple parameters depending on the requirement.
  • Methods can be defined with one or more parameters of different types.
  • Parameters in Java can be of various valid data types, including int, double, String, boolean, and more.
  • We can also define methods with no parameters.
  • We can pass a variable, a literal value or an expression as a parameter.
  • In Java, it is possible to pass an array as an argument to a method.
  • We can also pass an object as a parameter to a method.
  • In Java, it is permissible to declare multiple methods with identical names but differing parameter lists. This concept is known as method overloading.

Implementation:

public class Main {
    public static void main(String[] args) {
        // Example with a single parameter
        greet("John");
        // Example with multiple parameters
        int result = add(2, 3);
        System.out.println(result);
        double doubleResult = add(2.5, 3.5);
        System.out.println(doubleResult);
    }
    public static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }
    public static int add(int num1, int num2) {
        return num1 + num2;
    }
    public static double add(double num1, double num2) {
        return num1 + num2;
    }
}

Output:
Hello, John!
5
6.0

Return Types

Java methods can also have a return type, which specifies the type of value that the method returns after execution. The return type in Java can be any legitimate data type, including int, double, String, boolean, or even an object.

To specify a return type for a method, we need to replace the void keyword in the method signature with the appropriate data type. For example, a method that returns an integer value would have a method signature like this:

public int methodName() {
    // Method body
}

Here’s an example of a method that returns a String value:

public String getGreeting() {
    String greeting = "Hello, world!";
    return greeting;
}

We can also have methods that return objects of a user-defined class. For example:

public MyClass getObject() {
    MyClass obj = new MyClass();
    // Do some operations on obj
    return obj;
}

It is important to note that in Java when a method has a return type other than void, it must include a return statement in its body that returns a value of the specified type. Failure to include a return statement or to provide a value in the return statement will result in a compilation error.

Void methods, as the name suggests, do not return any value. They are beneficial when we need to perform certain operations without returning any value. Here’s an example of a void method:

public void printHello() {
    System.out.println("Hello, world!");
}

In summary, return types allow methods to return values of different data types, including user-defined objects. Void methods are useful when we don’t need to return any value from a method.

Access Modifiers

Java methods can have access modifiers that determine the level of access to a method.

  • Java offers four types of access modifiers: public, private, protected, and the default access modifier.
  • Public methods can be accessed by any class, anywhere.
  • Private methods are accessible only within the same class where they are defined.
  • Protected methods can be accessed within the same package or by a subclass of the class where they are defined.
  • Default methods are basically methods without explicitly specified access specifiers in the function definition.
  • The function definition starts directly with the keyword ‘class’ in case of a class, or with return type in case of methods.

Example:

public class AccessModifierExample {
    // default access modifier - accessible within the same package
    void displayDefault() {
        System.out.println("This is a default method");
    }
    // public access modifier - accessible from anywhere
    public void displayPublic() {
        System.out.println("This is a public method");
    }
    // private access modifier - accessible only within the same class
    private void displayPrivate() {
        System.out.println("This is a private method");
    }
    // protected access modifier - accessible within the same package or by a subclass of the class
    protected void displayProtected() {
        System.out.println("This is a protected method");
    }
    public static void main(String[] args) {
        AccessModifierExample obj = new AccessModifierExample();
        obj.displayDefault(); // accessible within the same package
        obj.displayPublic(); // accessible from anywhere
        obj.displayPrivate(); // accessible only within the same class
        obj.displayProtected(); // accessible within the same package or by a subclass of the class
    }
}
// Another class in the same package
class AnotherClass {
    public static void main(String[] args) {
        AccessModifierExample obj = new AccessModifierExample();
        obj.displayDefault(); // accessible within the same package
        obj.displayPublic(); // accessible from anywhere
        obj.displayPrivate(); // not accessible from another class
        obj.displayProtected(); // accessible within the same package or by a subclass of the class
    }
}
// Subclass in the same package
class Subclass extends AccessModifierExample {
    public static void main(String[] args) {
        Subclass obj = new Subclass();
        obj.displayDefault(); // accessible within the same package
        obj.displayPublic(); // accessible from anywhere
        obj.displayPrivate(); // not accessible from subclass
        obj.displayProtected(); // accessible from subclass
    }
}

Output:
This is a default method
This is a public method
This is a private method
This is a protected method
This is a default method
This is a public method

error: displayPrivate() has private access in AccessModifierExample
        obj.displayPrivate(); // not accessible from subclass
           ^
AccessModifierExample.java:35: error: displayPrivate() has private access in AccessModifierExample
        obj.displayPrivate(); // not accessible from another class
           ^
2 errors``

The above class demonstrates the following access modifiers:

  • Default access modifier: A method with no access modifier specified. It is accessible within the same package. Example: displayDefault()
  • Public access modifier: A method with the public keyword. It is accessible from anywhere. Example: displayPublic()
  • Private access modifier: A method with the private keyword. It is accessible only within the same class. Example: displayPrivate()
  • Protected access modifier: A method with the protected keyword. It is accessible within the same package or by a subclass of the class. Example: displayProtected()

The main method in the AccessModifierExample class calls all the methods. AnotherClass in the same package can also access the default and public methods. The Subclass extends AccessModifierExample and can access the default, public, and protected methods but not the private method.

Static Method in Java

In Java, a static method is associated with a class rather than an instance of the class. Static methods can be accessed using the class name itself, without requiring an object of the class to be created. Static methods are commonly used for utility functions or operations that do not require instance-specific data. They are defined using the “static” keyword and can only access other static members of the class.

class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int multiply(int a, int b) {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        int sum = MathUtils.add(5, 3);
        System.out.println("Sum: " + sum);
        
        int product = MathUtils.multiply(4, 2);
        System.out.println("Product: " + product);
    }
}

In the code above, we have a class MathUtils that contains two static methods: add() and multiply(). These methods can be called directly on the class without creating an instance of it. In the Main class, we demonstrate how to use these static methods by calling them and printing the results.

Output:
Sum: 8
Product: 8

Finalize() Method in Java

The finalize() method is a special method in Java that is automatically called by the garbage collector before an object is destroyed. It allows the object to perform any necessary cleanup or finalization actions before being deallocated from memory. The finalize() method in Java is invoked by the garbage collector when it determines that an object no longer has any references.

It is important to be aware that the use of the finalize() method is not recommended in contemporary Java programming due to its limitations and potential performance impact. It is recommended to use alternative approaches, such as try-with-resources or explicit resource management, for resource cleanup.

class MyClass {
    private String name;
    MyClass(String name) {
        this.name = name;
    }
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("Finalizing " + name);
            // Perform cleanup operations
            // ...
        } finally {
            super.finalize();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass("Object 1");
        MyClass obj2 = new MyClass("Object 2");
        // Let's assume the objects are no longer needed
        obj1 = null;
        obj2 = null;
        // Explicitly request garbage collection
        System.gc();
    }
}

In this code, the MyClass has been modified to include a constructor that accepts a name parameter. In the finalize() method, we have added a print statement to indicate the finalization process of each object. In the Main class, two instances of MyClass are created and assigned to obj1 and obj2, respectively. After setting both objects to null, we explicitly request garbage collection using System. gc().

When the garbage collector runs, it will identify the objects that are no longer referenced (obj1 and obj2) and invoke the finalize() method for each of them. The output will show the finalization message for each object, indicating that the cleanup operations inside the finalize() method are being performed.

Java Method Overloading

In Java, method overloading is a language feature that enables the definition of multiple methods with the same name but different parameter lists. The parameters can differ in their number, data types, and order.

Method overloading can make the code more readable and easier to understand. Instead of having multiple methods with different names that perform similar tasks, you can have a single method name that can be called with different parameters to achieve different results.

Here is an example of overloading methods in Java:

class OverloadingExample {
    public static int add(int a, int b) {
        return a + b;
    }
    public static double add(double a, double b) {
        return a + b;
    }
    public static String add(String a, String b) {
        return a.concat(b);
    }
}

public class Main {
    public static void main(String[] args) {
        int sum1 = OverloadingExample.add(5, 10);
        double sum2 = OverloadingExample.add(5.5, 10.5);
        String sum3 = OverloadingExample.add("Hello", " World");   
        System.out.println("Sum of integers: " + sum1);
        System.out.println("Sum of doubles: " + sum2);
        System.out.println("Concatenation of strings: " + sum3);
    }
}

Output:
Sum of integers: 15
Sum of doubles: 16.0
Concatenation of strings: Hello World

In the provided example, there are three methods named “add” with different parameter lists. The first method accepts two integers and returns their sum, the second method takes two doubles and returns their sum, and the third method takes two strings and concatenates them.

When the “add” method is called with specific parameters in the main method, the corresponding method is executed based on the passed arguments. This approach enhances code readability and allows for more concise programming.

Method overloading provides flexibility to developers in terms of method design and usage. It empowers developers to create code that is more concise, efficient, and comprehensible, leading to improved readability and maintainability.

Java Method Overriding

Method overriding is a feature in Java that enables a subclass to define its own implementation of a method that is already present in its superclass. The overridden method must have the same name, return type, and parameters as the method in the superclass.

The fundamental concept of method overriding in Java is to allow the subclass to provide its own implementation of a method that is already defined in its superclass. This enables the subclass to offer a more specific or relevant implementation of the method while preserving the same method signature.

Let’s see an example of method overriding:

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}
class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}
public class Main {
   public static void main(String args[]) {
      Animal a = new Animal();   
      Animal b = new Dog();   
      a.move();   
      b.move();   
   }
}

Output:
Animals can move
Dogs can walk and run

Here, we have a superclass Animal that has a method move() which prints “Animals can move”. Then, we have a subclass Dog that extends Animal and overrides the move() method to print “Dogs can walk and run”.

In the main method, we instantiate objects of the classes Animal and Dog and then invoke their respective move() methods. When we call a.move(), it invokes the move() method of the Animal class, and when we call b.move(), it invokes the move() method of the Dog class.

The output shows that the overridden method in the Dog class is called when we call b.move(), and it prints “Dogs can walk and run”.

Method overriding and method overloading are distinct concepts in Java. While method overloading involves having multiple methods with the same name but different parameters within the same class, method overriding refers to the practice of providing a specific implementation of a method in a subclass that is already defined in its superclass. Method overriding only occurs in subclasses and only when the method signature is the same as the method in the superclass.

In conclusion, method overriding is a powerful feature of object-oriented programming that allows subclasses to provide their implementation of methods defined in the superclass. It provides flexibility and customization in class implementation, and it plays a crucial role in inheritance.

Best Practices for Using Methods:

To ensure code readability and maintainability, it is crucial to adhere to best practices when using methods in your Java code. One of the fundamental principles is to assign descriptive names to your methods, accurately reflecting their purpose and functionality. You should also use comments to explain what each method does and what parameters it takes. Additionally, you should keep your methods small and focused on a single task, rather than trying to do too much in one method.

Methods find applications in various real-world scenarios, ranging from basic mathematical computations to intricate operations such as file manipulation and data processing.

For example, you could employ a method to compute the overall expenditure of a transaction by considering the item’s quantity and price. Or, you might use a method to read data from a file and process it in some way. Whatever your needs, methods can help you build more efficient, readable, and maintainable code.

Conclusion

Java methods are an essential part of Java programming. They are the code segments that carry out a particular operation, providing reusability within the program. Java methods are defined using a specific syntax and can take parameters and return values.

In this article, we discussed the fundamental aspects of Java methods, including their definition and syntax. We also discussed the importance of methods in Java programming and how they can make our code more efficient and easier to maintain.

We explored different types of methods, including methods with parameters, return types, and access modifiers. We also learned about method overloading and overriding, which allow us to create methods with the same name but different functionality.

Overall, Java methods are a powerful tool for developers to write clean, efficient, and maintainable code. By using methods, we can break down complex tasks into smaller, more manageable parts, making our programs easier to read and maintain.

Tags:

Leave a Reply

Your email address will not be published. Required fields are marked *