Diferencia entre revisiones de «Constructor (informática)»
Contenido eliminado Contenido añadido
m Mantenimiento de Control de autoridades |
Incorporación de códigos e información que ejemplifican la sobrecarga de constructores |
||
Línea 1:
En [[programación orientada a objetos|Programación Orientada a Objetos]] (POO), un '''constructor''' es una [[subrutina]] cuya misión es inicializar un [[objeto (programación)|objeto]] de una [[clase (programación)|clase]]. En el constructor se asignan los valores iniciales del nuevo objeto.
Se utiliza para crear tablas de [[Clase (informática)|clases]] virtuales y poder así desarrollar el [[Polimorfismo (programación orientada a objetos)|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.
Línea 24:
Si se define un constructor con parámetros (definido explícitamente) el constructor por <code>default</code> se reemplaza por este.
<br />
=== Sobrecarga de constructores ===
A continuación se creará un constructor explícito para una clase simple, utilizando una clase <code>Persona</code> con una serie de atributos.
Línea 31 ⟶ 34:
class Persona
{
//
private String nombre;
private int edad;
Línea 38 ⟶ 41:
//CONSTRUCTORES
public Persona() {} //
public Persona(String nombre, int edad, String empleo, double salario)
{
Línea 52 ⟶ 55:
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
<source lang="java">
Línea 64 ⟶ 67:
<source lang="java">
Persona pers02 = new Persona("Pepe Pérez", 30, "Programador", 25000);
</source>Lo anterior permite asignar la información correspondiente a los atributos de <code>nombre</code>, <code>edad</code>, <code>empleo</code> y <code>salario</code>, 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:<syntaxhighlight lang="java" line="1">
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)
//2do constructor
public Persona(String nombre, int edad, String empleo, double salario)
{
asignarNombre(nombre);
asignarEdad(edad);
asignarEmpleo(empleo);
asignarSalario(salario);
}
//3er ocnstructor
public Persona(String nombre, String empleo,)
{
asignarNombre(nombre);
asignarEmpleo(empleo);
}
//4to constructor
public Persona(String nombre, int edad)
{
asignarNombre(nombre);
asignarEdad(edad);
}
//5to constructor
public Persona(int edad, String nombre)
{
asignarNombre(nombre);
asignarEdad(edad);
}
//6to constructor
public Persona(String nombre)
{
asignarNombre(nombre);
}
//...
}
</syntaxhighlight>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 cuanta 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:<syntaxhighlight lang="java" line="1">
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
</syntaxhighlight>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.{{Control de autoridades}}
[[Categoría:Programación orientada a objetos]]
[[Categoría:Subrutinas]]
| |||