It seems but it is not

In Java, a constructor looks like a method, but it really isn't.

Why? What makes a constructor not a method?

Very simple, since you don't want them to talk to you about differences: JAVA has decided so, that's why in its documentation it always talks about constructors or methods .

Also, by sketching a definition (inevitably based on differences), as its name implies, a constructor has the ability to construct an instance of a class. A method does not build, it does not create, it only obeys the order that has been given to it.

Constructors (§8.8) are similar to methods, but cannot be invoked directly by a method call; they are used to initialize new class instances. Like methods , they may be overloaded (§8.8.8).

Constructors are similar to methods (they look but they are not), but they cannot be called directly by a method call, but are used to initialize new instances of classes. Like methods , they can be overridden.

Java documentation always makes a difference:

8.4.2. Method Signature

Two methods or constructors, M and N, have the same signature if they have the same name, the same type parameters (if any) (§8.4.4), and, after adapting the formal parameter types of N to the the type parameters of M, the same formal parameter types.

Also:

8.4.1. Formal parameters

The formal parameters of a method or constructor , if any, are specified by a list of comma-separated parameter specifiers. If a method or constructor has no formal parameters, only an empty pair of parentheses appears in the declaration of the method or constructor .

Here is an interesting article (in English).

For example, it says, among other things, that in the same class you can have a constructor (this always bears the name of the class) and a method with the same name... the two will work differently, each one doing the function for which exists.

In short, a constructor looks like a method, but it is just a constructor, because JAVA wants it to be. :)

• The important difference between constructors and methods is that constructors create and initialize objects that do not yet exist, while methods perform operations on objects that already exist.

• Constructors cannot be called directly. They are called implicitly when the keyword newcreates an object. Methods can be called directly on an object that has already been created with new.

• Constructor and method definitions look similar in code. They can take parameters, they can have modifiers (for example, public), and they have method bodies.

• Constructors must be named with the same name as the class name. They can't return anything, not even void (the object itself is the implicit return).

• Methods must be declared to return something, and when they don't return anything it has to be indicated using void.

NO

A constructor in Java is not a method and it is not a special method either. It looks like a method without Result, but it is not a method.

The Java Language Specification is the Java language reference document.

We can read in 8.1.6. Class Body and Member Declarations

The body of a class can contain declarations of members of a class, that is, fields (§8.3), methods (§8.4), classes (§8.5), and interfaces (§8.5).
The body of a class may also contain instance initializers (§8.6), static initializers (§8.7), and constructor declarations (§8.8) for the class.

We can read in 8.8. Constructor Declarations

Constructors are not members.

If a constructor were a method then a constructor would be a member. And the JLS clearly says no, a constructor is not a member, so it can't be a method.

YES and NO

• In the sense of the word method in Spanish, the constructor is.

• Technically and formally it is not, at least not in Java.

It is very common to explain (especially to OOP newbies) what a constructor is, comparing it to methods. I find it perfectly valid, it is unproductive to get too dogmatic. But if I explain it like this I also have to mention that there are important differences:

• A constructor in Java does not have an eligible name. It is always the name of the class you are building.
• A constructor is not inherited by its class. A subclass has its own constructors, within them you have to call the constructors of the superclass (if you don't implicitly go through the default constructor)
• As there is no inheritance of constructors, obviously there is also no overriding (@Override) of constructors, nor can they be hidden (if I call the constructor of a class, I will always call this class, never a subclass).
• It's obvious from the above points that you can't declare a constructor staticor final(it doesn't make sense).
• The constructor does not declare a result. It is not necessary, because the constructor can only be used explicitly with the keyword newthat returns a new instance of the class in question, or as super(...)calling a constructor of the superclass within a constructor.

Apart from that it has many aspects in common with a method

• It is a block of code identified by a name and the types of its arguments.
• There may be more than one, but only with different arguments.
• It has a scope (scope) and you can execute code in the constructor as is in methods
• Visibility can be changed with private, protectedor public.

In short: Looking at the constructor as a method (aware that it is not) does not put the sanity of an engineer in danger, while not losing awareness that there are important differences as stated above.

Dogmatically insisting that "it is not a method" without referring to the importance of the differences is as useful and pedagogical as saying to a child "the old man from Christmas is a lie, the postman brought the gifts."

In order not to start a pointless debate I want to base my answer on what the official documentation describes .

Constructors A class contains constructors that are called to create objects from the project class. Constructor declarations are similar to method declarations, except that they use the class name and do not have a return type.

A constructor is similar to a method but is not the same due to the differences mentioned.

For example, the Car class has a constructor:

public Automovil(int iniciaCadencia, int iniciaVelocidad, int iniciaMaquinaria) {
    maquinaria = iniciaMaquinaria;
    cadencia = iniciaCadencia;
    velocidad = iniciaVelocidad;
}

AutomovilTo create a new named object miAutomovil, a constructor is called by the new operator:

Automovil miAutomovil = new Automovil(30, 0, 8);

new Automovil(30, 0, 8)creates memory space for the object and initializes its fields.

Although Automovilit has only one constructor, it could have others, including a no-argument constructor:

public Automovil() {
    maquinaria = 1;
    cadencia = 10;
    velocidad = 0;
}

Automovil miAutomovil = new Automovil();Calls the constructor with no arguments to create a new object Automovilnamed miAutomovil.

Constructors in Java are a special type of method which matches the name of the class and has no return type, when the new keyword is written, Java reserves space in memory to store the object, it also takes care of looking for the constructor, constructors are often used to initialize the instance variables of the Class

PS: They are methods since they receive parameters and have logic inside their body, but they are a special type of method which is only accessed when the new keyword is used

Source : Oracle Java Certified Associate (JAVA OCA 8 ).