Java Methods

Table Of Contents
  1. Methods in Java
  2. Key Concepts of Java Methods
  3. Method Declaration Syntax
  4. Example of a Method
  5. Types of Methods
  6. Method Overloading
  7. Method Overriding
  8. Method Parameters

Methods in Java

Methods in Java are blocks of code that perform a specific task and are designed to be reusable. They define the behavior of objects and can be invoked to perform operations, compute values, or interact with other methods and objects. Understanding methods is crucial for structuring code efficiently and achieving modularity and reusability.

Key Concepts of Java Methods

  • Declaration: A method must be declared within a class or an interface (in the case of default methods). The method declaration specifies the access level, return type, method name, parameters (if any), and the method body.
  • Signature: The method signature consists of the method name and the parameter list. It is used to identify a method uniquely.
  • Return Type: A method can return a value of a specific type or be void if it does not return any value.
  • Parameters: Methods can accept input values known as parameters, which are specified within parentheses.
  • Method Body: The method body contains the statements that define what the method does.

Method Declaration Syntax

Java
accessModifier returnType methodName(parameterList) {
    // method body
}

Example of a Method

Java
public class MyClass {
    // A method that returns the sum of two integers
    public int add(int a, int b) {
        int sum = a + b;
        return sum;
    }

    // A method that prints a message
    public void printMessage() {
        System.out.println("Hello, World!");
    }
}

Types of Methods

1. Instance Methods

Instance methods require an object of the class to be invoked. They operate on the instance variables of the class.

  • Example:
Java
  public class MyClass {
      public void display() {
          System.out.println("This is an instance method.");
      }
  }

  public class Test {
      public static void main(String[] args) {
          MyClass obj = new MyClass();
          obj.display(); // invoking instance method
      }
  }

2. Static Methods

Static methods belong to the class rather than an instance. They can be called without creating an instance of the class.

  • Example:
Java
  public class MyClass {
      public static void display() {
          System.out.println("This is a static method.");
      }
  }

  public class Test {
      public static void main(String[] args) {
          MyClass.display(); // invoking static method
      }
  }

3. Abstract Methods

Abstract methods are declared without a body and must be implemented by subclasses. They can only be declared in abstract classes or interfaces.

  • Example:
Java
  public abstract class MyAbstractClass {
      public abstract void display();
  }

  public class MyClass extends MyAbstractClass {
      public void display() {
          System.out.println("This is an abstract method implementation.");
      }
  }

4. Final Methods

Final methods cannot be overridden by subclasses. This ensures that the method implementation remains unchanged.

  • Example:
Java
  public class MyClass {
      public final void display() {
          System.out.println("This is a final method.");
      }
  }

5. Synchronized Methods

Synchronized methods are used to control access to a method by multiple threads. Only one thread can access a synchronized method at a time.

  • Example:
Java
  public class MyClass {
      public synchronized void display() {
          System.out.println("This is a synchronized method.");
      }
  }

Method Overloading

Method overloading allows a class to have more than one method with the same name, but different parameter lists. It is a way to achieve compile-time polymorphism.

  • Example:
Java
  public class MyClass {
      public void display() {
          System.out.println("No parameters");
      }

      public void display(int a) {
          System.out.println("One parameter: " + a);
      }

      public void display(int a, int b) {
          System.out.println("Two parameters: " + a + ", " + b);
      }
  }

Method Overriding

Method overriding allows a subclass to provide a specific implementation for a method that is already defined in its superclass. It is a way to achieve runtime polymorphism.

  • Example:
Java
  public class ParentClass {
      public void display() {
          System.out.println("Parent class method");
      }
  }

  public class ChildClass extends ParentClass {
      @Override
      public void display() {
          System.out.println("Child class method");
      }
  }

  public class Test {
      public static void main(String[] args) {
          ChildClass obj = new ChildClass();
          obj.display(); // invokes child class method
      }
  }

Method Parameters

1. Pass by Value

In Java, method parameters are always passed by value. This means that a copy of the actual parameter value is passed to the method.

  • Example:
Java
  public class MyClass {
      public void modifyValue(int a) {
          a = 20;
      }

      public static void main(String[] args) {
          MyClass obj = new MyClass();
          int x = 10;
          obj.modifyValue(x);
          System.out.println(x); // Output: 10
      }
  }

2. Variable Arguments (Varargs)

Java allows you to pass a variable number of arguments to a method using varargs. This is done by using three dots (...) in the method parameter.

  • Example:
Java
  public class MyClass {
      public void display(int... numbers) {
          for (int number : numbers) {
              System.out.println(number);
          }
      }

      public static void main(String[] args) {
          MyClass obj = new MyClass();
          obj.display(1, 2, 3, 4, 5); // can pass any number of arguments
      }
  }

By understanding and using methods effectively, you can write modular, reusable, and maintainable code in Java. Methods allow you to encapsulate functionality, making your code easier to understand and manage.

Scroll to Top