Constructor (informática)

En Programación Orientada a Objetos (POO), un constructor es una subrutina cuya misión es inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo objeto.

Se utiliza para crear tablas de clases virtuales y poder así desarrollar el polimorfismo, una de las herramientas de la programación orientada a objetos. Al utilizar un constructor, el compilador determina cual de los objetos va a responder al mensaje (virtual) que hemos creado. Tiene un tipo de acceso, un nombre y un paréntesis.

Java

En Java es un método especial dentro de una clase, que se llama automáticamente cada vez que se crea un objeto de esa clase.

Posee el mismo nombre de la clase a la cual pertenece y no puede devolver ningún valor (ni siquiera se puede especificar la palabra reservada void). Por ejemplo, si añadiéramos a la clase SSuma un constructor, tendríamos que llamarlo también SSuma. Cuando en una clase no se escribe propiamente un constructor, Java asume uno por defecto.

Constructor por defecto

Un constructor por defecto es un constructor sin parámetros que no hace nada. Sin embargo será invocado cada vez que se construya un objeto sin especificar ningún argumento, en cuyo caso el objeto será iniciado con los valores predeterminados por el sistema (los atributos numéricos a cero, los alfanuméricos a nuloPeq, y las referencias a objetos a null).

Ejemplo

Un constructor por defecto para la clase SSuma quedaría así:

   public SSuma() {}

Como se observa el constructor no posee ningún parámetro, ya que como no ha sido definido propiamente por el programador, Java lo hace por default.

Si se define un constructor con parámetros (definido explícitamente) el constructor por default se reemplaza por este.

Sobrecarga de constructores

A continuación se creará un constructor explícito para una clase simple, utilizando una clase Persona con una serie de atributos.

Primero se declara la clase con sus atributos:

 class Persona
 {
   //Atributos
   private String nombre;
   private int edad;
   private String empleo;
   private double salario;
  
   //Constructores
   public Persona() {} //Constructor sin parámetros (constructor por defecto)
   public Persona(String nombre, int edad, String empleo, double salario)
   {
       asignarNombre(nombre);
       asignarEdad(edad);
       asignarEmpleo(empleo);
       asignarSalario(salario);
   }
   //...
 }

El constructor sin parámetros es reemplazado por el constructor explícito. En este ejemplo se puede observar que los constructores preferentemente se declaran públicos para que puedan ser invocados desde cualquier parte.

Una línea como la que se presenta a continuación, invocará al constructor (por defecto) sin parámetros:

   Persona pers01 = new Persona();// invoca al constructor Persona

El operador new crea un nuevo objeto, en este caso de la clase Persona, y a continuación se invoca al constructor de la clase para realizar las operaciones de iniciación que estén programadas.

A continuación se invocará al constructor con parámetros, que se introducirán en el orden especificado en el constructor.

Persona pers02 = new Persona("Pepe Pérez", 30, "Programador", 25000);

Lo anterior permite asignar la información correspondiente a los atributos de nombre, edad, empleo y salario, dicho de otra forma, el constructor permite dar los primeros valores o inicializar los atributos de la clase persona, sin embargo, es importante mencionar que además de constructor por defecto, podemos definir más de un constructor, en donde la diferencia entre uno y otro debe ser el tipo de cada uno de esos parámetros. A continuación se ejemplifica de acuerdo a la clase Persona:

 class Persona
 {
   //Atributos
   private String nombre;
   private int edad;
   private String empleo;
   private double salario;
  
   //Constructores
   public Persona() {} //Constructor sin parámetros (constructor por defecto)
   
   //2º constructor
   public Persona(String nombre, int edad, String empleo, double salario)
   {
       asignarNombre(nombre);
       asignarEdad(edad);
       asignarEmpleo(empleo);
       asignarSalario(salario);
   }
   
   //3er constructor
   public Persona(String nombre, String empleo)
   {
       asignarNombre(nombre);
       asignarEmpleo(empleo);
   }
   
   //4º constructor
   public Persona(String nombre, int edad)
   {
       asignarNombre(nombre);
       asignarEdad(edad);
   }
   
   //5º constructor
   public Persona(int edad, String nombre)
   {
       asignarNombre(nombre);
       asignarEdad(edad);
   }
   
   //6º constructor
   public Persona(String nombre)
   {
       asignarNombre(nombre);
   }
   //...
 }

El tercer, cuarto y quinto constructor parecen iguales, pero no lo son, tienen el mismo número de parámetros (en este caso dos), pero no son del mismo tipo, ya que el tercer constructor tiene ambos parámetros de tipo String, pero en el cuarto constructor uno es de tipo String y otro int, por lo tanto eso no ocasionará problemas. Tal vez pareciera que el cuarto y quinto constructor sí son iguales, pero ahora se debe tomar en cuenta el orden, en el cuarto constructor especifica que primero recibe un String y después un int, y el quinto constructor primero recibe un int y después un String, entonces en estos casos ya es importante el orden de los parámetros. Y el último constructor ejemplifica que los constructores, además del constructor por defecto, deben tener desde un parámetro hasta n número de parámetros. La invocación para los constructores anteriores, sería de la siguiente forma:

Persona pers01 = new Persona();//Uso del constructor por defecto
Persona pers02 = new Persona("Pepe Pérez", 30, "Programador", 25000);//Uso del 2do constructor
Persona pers03 = new Persona("Pepe Pérez","Programador");//Uso del 3er constructor
Persona pers04 = new Persona("Pepe Pérez", 30);//Uso del 4to constructor
Persona pers04 = new Persona(30, "Pepe Pérez");//Uso del 5to constructor
Persona pers05 = new Persona("Pepe Pérez");//Uso del 6to constructor

En conclusión, al realizar la modificación para disponer de más de constructor, que es el ejemplo anterior, le llamaremos sobrecarga de métodos, es decir, consiste en definir o crear más de un constructor, en donde la diferencia será entre cada uno de ellos será el tipo de cada uno de los parámetros que reciba.

• Datos: Q1049476