¿Podemos definir un nombre de método igual que el nombre de clase en Java?

Podemos tener un nombre de método igual que un nombre de clase en Java, pero no es una buena práctica hacerlo. Este concepto puede ser claro a través de ejemplos en lugar de explicaciones. En el siguiente ejemplo, se llama a un constructor predeterminado cuando se crea un objeto y se llama a un método con el mismo nombre usando obj.Main() .

Ejemplo 1 :

// Java program to demonstrate that a method
// can have same name as a Constructor or
// class name
 
import java.io.*;
 
public class Main {
    void Main()
    {
        System.out.println(
            "My name is same as Constructor name!");
    }
    public static void main(String[] args)
    {
          // create an object of class
          // Main
        Main obj = new Main();
           
          // call the method
        obj.Main();
    }
}

My name is same as Constructor name!

Ejemplo 2: para verificar si realmente muestra la propiedad del constructor o no, podemos verificar de esta manera.

// Java program to demonstrate
// checking whether a method is acting like a
// constructor or just a method
 
import java.io.*;
 
public class Main {
 
    // default constructor
    Main() { this(5); }
    /*
      Main(int a) {
        System.out.println(a);
      }
    */
 
    // Just a method
    // not a parameterized constructor
    void Main(int a)
    {
        System.out.println("I am a method");
    }
   
    public static void main(String[] args)
    {
        // create an object
        Main obj = new Main();
           
          // obj.Main();
    }
}

Error:

error: constructor Main in class Main cannot be applied to given types;
    Main() { this(5); }
             ^
  required: no arguments
  found: int
  reason: actual and formal argument lists differ in length
1 error

Aquí no llamamos a void Main(int) a través de un objeto, pero llamamos a través de this(int) y muestra un error, por lo que no puede ser un constructor. Esto le dará un error que muestra que no hay ningún constructor parametrizado disponible, pero creemos que ya lo tenemos, que es void Main(int a) . Pero void Main(int a) no actúa así para demostrar que simplemente elimine la sección comentada en el código anterior y solo funcionará.

// Java program to demonstrate that
// constructor is different from method
 
import java.io.*;
 
public class Main {
 
    // default constructor
    Main() { this(5); }
 
    // parameterized constructor
    Main(int a) { System.out.println(a); }
 
    // method but not a constructor
    void Main(int a)
    {
        System.out.println(
            "I am just a method, not  a constructor");
    }
 
    public static void main(String[] args)
    {
        Main obj = new Main();
        // obj.Main();
    }
}

5

Ejemplo 3: 

// Java program to demonstrate
// checking whether a method is acting like a
// constructor or just a method
 
import java.io.*;
 
public class Main {
    // default constructor
    Main() { System.out.println("Hey"); }
 
    // method, not a constructor
    void Main()
    {
        System.out.println("I can have return type too.");
    }
 
    public static void main(String[] args)
    {
 
        // create an object
        Main obj = new Main();
    }
}

Hey

Finalmente, podemos concluir que cuando tenemos un tipo de retorno para los métodos con el mismo nombre que el nombre de una clase, pierde las características que tienen los constructores y se comportará como un método. Y esto es una mala práctica en la programación.