Introduction to Methods in Java: A Detailed Guide

Imagine you’re building a LEGO castle. Each tiny brick represents a Methods in Java. These methods aren’t just random pieces; they have specific jobs. Some organise the castle’s rooms (like encapsulating logic), others manage the treasure (that’s data management), and all of them can be reused in different castles (that’s reusability!)

Willing to craft a masterpiece of code, where each piece fits perfectly and serves a distinct purpose? This comprehensive blog delves deep into the essence of Methods in Java, unravelling their potential to revolutionise your code’s structure, efficiency, and readability.

Table of Contents

1) What is a Method in Java?  

2) Declaration of Java Methods 

3) How to name Methods in Java? 

4) How to Call Methods in Java? 

5) Types of Java Methods  

6) Further Classifications of Java Methods  

7) Benefits of Using Java Methods 

8) Conclusion 

What is a Method in Java? 

As mentioned previously in the introduction, Java contains Methods for code reusability and modification. A Method is usually written just once and then reused as desired, eliminating the necessity of writing it multiple times. The main() method is also the phase for the Java Virtual Machine (JVM) to initiate the execution of the Java program.

The syntax of the ‘main() method’ is given below:
 

public static void main(String args[])

 

The components involved in the above syntax are part of the Method declaration protocol in Java, which will be further explained in the blog.

Another characteristic of Methods is that they are also referred to as functions because they are used to perform specific actions. Java classes always have Methods declared inside them, where the Method is defined with a name followed by parentheses. Java also offers predefined Methods like ‘System.out.println()’, where the  Method println() takes an argument of what needs to be printed.

As an example,
 

public class Main {  Static void amethod() {  // execution code body  }  }  }

 

In this example, ‘method ()’ is the name of the Method, and ‘static’ is a keyword that indicates the Method is part of the Main class rather than being an object of it. Finally, ‘void’ is a keyword that indicates the Method does not have a return value.
 

 

Declaration of Java Methods

The declaration of Methods in Java details the Method’s attributes, such as its return type, name, arguments, and visibility. It also contains seven components within itself, referred to as the Method header.

Example of a Method declaration template: 
 

Public int sum (int a, int b)  {  //method body  }

 

The components of the Method header above are described as follows: 

Method Signature

Each Method has a signature that is included in the Method declaration. This signature contains the Method name and parameter list.  

Access Specifier

The Access Specifier, also known as Modifier, determines the Method’s access type and visibility. In Java, there are four kinds of access specifiers available: 

1) Public: The public keyword enables the Method’s access from all classes in the application. 

2) Private: The private keyword limits the accessibility of the  Method to only the classes within which it is defined. 

3) Protected: The protected keyword allows Method accessibility within the same package or subclasses in other packages. 

4) Default: If none of the other three access specifiers are used in the Method declaration, Java uses the ‘default’ access specifier by default. This means that the Method’s visibility is limited to the same package. 

Return Type

The return type is the data type in Java that the Method returns. This data type will either return a value from the Method or void if it does not return a value. It is obligatory to declare the return type in the  Method’s syntax. Return types usually include primitive types such as ‘int’, ‘double’, ‘float’ or ‘void’. It must be ensured that the data type returned by the Method is compatible with the return type specified by the Method. 

Method Name

The Method name is an identifier whose purpose is to refer to a particular Method within a program. This name is usually unique and is used to define the Method’s functionality. For example, if we need to create a Method for the addition of two numbers, the Method’s name will be ‘addition()’. This is because a Method is invoked or called by its name.

Start coding your future with Java – the language that powers the digital world - join our Javascript and Query Training now!

Parameter List

This list of parameters is comma-separated and enclosed within parentheses. It also has the variable name preceded by the data type. In cases where the Method lacks any parameters, the parentheses can be left empty.  

Exception List

The Method may possibly throw an exception, in which case they must be specified as a list. Java has a system of exception handling that uses two keywords: ‘throw’ and ‘throws’. The ‘throws’ keyword is used to specify which exceptions can be thrown from a Method, in contrast the ‘throw’ keyword is used to explicitly throw an exception inside the Method or a block of code.  

The ‘throws’ keyword is usually used to declare exceptions that can occur during the program’s execution. However, a Method that declares that it throws an exception is not obligated to handle the exception itself. Additionally, exceptions that are checked during runtime need to be thrown using the ‘throws’ keyword, while unchecked exceptions are not explicitly thrown in the code.  

Method Body

This component of the Method header contains the code statements that are utilised to carry out tasks. As for the syntax, the Method body is generally enclosed within the curly braces {}.

For e.g.,

float addNums() {  //code body }

 

How to name  Methods in Java? 

A Java Method acts as a block of code, performing a particular task and can be called by other parts of the program. Naming Methods in Java are important for the readability and clarity of the code. Here are some guidelines to follow when choosing a name for a Method:

a) The name should reflect what the Method does (for example, if the Method calculates the average of two numbers, use average() or mean())

b) The name should start with a lowercase verb that describes the action of the Method (for example, calculate(), print(), sort())

c) If the name consists of more than one word, use camelCase notation, which means that the first word is lowercase and the subsequent words are capitalised without any spaces (for example, calculateAverage(), printMessage(), sortArray())

Unlock Your Potential with our Firebase Training – register today and master the tools to build scalable and dynamic applications!

How to call Methods in Java?

To call a Method in Java, you need to use the name of the Method followed by parentheses () and a semicolon ;. For example, if you have a Method named sayHello() that prints “Hello” on the screen, you can call it like this:

sayHello();

If the Method is a Static Method, you can initiate it by using the class name without creating an object. For example, if you have a class named Math with a static method named add() that returns the sum of two numbers, you can call it like this:

Person p = new Person(); //create an object of Person class p.greet(); //call the greet() method

If the Method is a Static Method, you can call it by using the class name without creating an object. For example, if you have a class named Math with a static method named add() that returns the sum of two numbers, you can call it like this:

int result = Math.add(10, 20); //call the static add() method

Here is a complete example that shows how to create and call different types of Methods in Java:
 

//create a class named Example public class Example {   //create a static method named sayHello   static void sayHello() {     System.out.println("Hello");   }   //create a non-static method named sayBye   void sayBye() {     System.out.println("Bye");   }   //create a static method named add that takes two parameters and returns their sum   static int add(int a, int b) {     return a + b;   }   //create a non-static method named multiply that takes two parameters and returns their product   int multiply(int a, int b) {     return a * b;   }   //create the main method   public static void main(String[] args) {     //call the static method sayHello     sayHello(); //prints Hello     //create an object of Example class     Example e = new Example();     //call the non-static method sayBye using the object     e.sayBye(); //prints Bye     //call the static method add using the class name and store the result in a variable     int sum = Example.add(10, 20); //sum is 30     //call the non-static method multiply using the object and store the result in a variable     int product = e.multiply(10, 20); //product is 200     //print the results     System.out.println("The sum is " + sum);     System.out.println("The product is " + product);   } }

 

Types of Java Methods 

The Java programming structure has two types of Methods: 

Pre-defined Method

Pre-defined Methods are those that have already been defined in the Java class libraries and are also known as built-in Methods or standard library Methods. These Methods can be used directly by calling or invoking them in the program at any point. Some examples of Pre-defined Methods are length(), equals(), sqrt(), compareTo(), etc.

As an example, 
 

public class Example  {  Public static void main(String[] args)  {  System.out.print(“The maximum number is: “+ Math.max(5,5));  }}

 

User-defined Method 

As the term suggests, User-defined Methods are written by the programmer. These Methods can also be modified as per necessity.  

As an example,  
 

public static void CalcEvenOdd(int num) { If(num%2==0)  System.out.println(num+” is even”);  Else         System.out.println(num+” is odd”);  }

 

In this example, the Method ‘CalcEvenOdd’ contains the argument ‘num’ declared an ‘int’. This Method returns no value and hence the program uses ‘void’ in the Method declaration.

Shape the Future of Tech with our App & Web Development Training – join us and become a sought-after expert!

Further classifications of Methods in Java

Here are different types of Methods in Java with some examples.  Given below is a brief overview of each type:

Static Method

A Static Method is a Method that belongs to the class and can be called without creating an object of the class. It has the keyword ‘static’ before the Method name. A Static Method can access only static variables and other Static Methods of the class. It cannot use this or ‘super’ keywords. The main Method is an example of a Static Method. To call a Static Method, we use the syntax ‘ClassName.methodName()’. For example:
 

//create a class with a static method public class Example {   //create a static method that prints a message   public static void printMessage() {     System.out.println("This is a static method");   } } //call the static method using the class name Example.printMessage(); //prints This is a static method

 

Sign up for our comprehensive Web Development Training With TypeScript and transform your skills - register now!

Instance Method

An Instance Method is associated with an individual instance of a class, providing behaviour related to that specific object. It does not have the keyword ‘static’ before the Method name. This can access both static and non-static variables and Methods of the class. It can also use this or ‘super’ keywords. To call an Instance Method, we use the syntax ‘objectName.methodName()’. For example:
 

//create a class with an instance method public class Example {   //create an instance method that prints a message   public void printMessage() {     System.out.println("This is an instance method");   } } //create an object of the class Example e = new Example(); //call the instance method using the object name e.printMessage(); //prints This is an instance method

 

Abstract Method

An Abstract Method is a Method that has no implementation and is declared with the keyword ‘abstract’. It can only be declared in an abstract class or an interface. This Method must be overridden by a subclass or a class that implements the interface. It cannot have a body, only a signature. To declare an Abstract Method, we use the syntax ‘abstract returnType methodName(parameterList);’. For example:
 

//create an abstract class with an abstract method abstract class Animal {   //create an abstract method that makes a sound   abstract void makeSound(); } //create a subclass that extends the abstract class class Dog extends Animal {   //override the abstract method and provide a body   void makeSound() {     System.out.println("Woof");   } } //create an object of the subclass Dog d = new Dog(); //call the overridden method using the object d.makeSound(); //prints Woof

 

Factory Method

A Factory Method is a Method that returns an object of a class based on some input parameters. It is used to create objects without exposing the logic of creation to the caller. It is also known as a factory pattern or a static factory Method. A Factory Method can be static or non-static, depending on the design. To create a Factory Method, we use the syntax ‘returnType methodName(parameterList) { //logic to create and return an object }’ . For example:
 

//create an interface for shapes interface Shape {   //declare a method to draw the shape   void draw(); } //create a class for circle that implements the interface class Circle implements Shape {   //implement the draw method   public void draw() {     System.out.println("Drawing a circle");   } } //create a class for square that implements the interface class Square implements Shape {   //implement the draw method   public void draw() {     System.out.println("Drawing a square");   } } //create a class for factory method class ShapeFactory {   //create a static factory method that takes a shape type as a parameter and returns a shape object   public static Shape getShape(String shapeType) {     //check the shape type and create the corresponding object     if (shapeType.equalsIgnoreCase("circle")) {       return new Circle();     } else if (shapeType.equalsIgnoreCase("square")) {       return new Square();     } else {       return null;     }   } } //call the factory method using the class name and the shape type Shape s1 = ShapeFactory.getShape("circle"); //returns a circle object Shape s2 = ShapeFactory.getShape("square"); //returns a square object //call the draw method using the shape objects s1.draw(); //prints Drawing a circle s2.draw(); //prints Drawing a square

 

Unlock your potential with our comprehensive Java Swing Development Training and become a coding maestro today!

Benefits of using Java Methods

Methods in Java enhance code quality and efficiency in several ways. Let’s talk about them in detail:

a) They enable you to write code once and reuse it multiple times, leading to a more modular and maintainable codebase.

b) Methods simplify complex logic into user-friendly interfaces, enhancing code clarity and comprehension.

c) Segmenting code into concise, well-named methods improves its readability and understandability.

d) They encapsulate intricate logic and data, simplifying management and maintenance.

e) Methods facilitate the division of code into distinct segments with specific responsibilities, bolstering code structure and organisation.

f) They break down code into smaller, more manageable pieces, increasing the overall modularity.

g) Smaller code units are easier to test and debug, enhancing the testability of the code.

h) Well-organised methods can boost performance by minimising the code execution footprint and aiding in optimisation.

Conclusion

Through this blog, we hope you possess the foundational expertise to effectively harness Methods in Java. Elevate your coding prowess by applying these concepts to create dynamic and efficient programs. With the power of Java Methods at your fingertips, you can tackle complex challenges and forge ahead in the world of software development.

Expand your knowledge about Methods in Java and learn to program your own applications - sign up for the Java Programming Training today!