Los constructores en java son métodos obligatorios que se encargan de dar un estado inicial a nuestro objeto. Estos métodos, tienen como característica principal que se llaman igual que la propia clase. Por lo tanto, debemos tener un método dentro de la clase Persona que se llame igual que ella.
Entonces, quizá te estás preguntando,… en la clase que definimos en el artículo anterior, no hemos programado ningún método constructor.
¿Entonces porque se puede construir un objeto de la clase persona si no existe un constructor?
Pues bien, estas en lo cierto. En la clase anterior no hemos creado ningún método constructor. Sin embargo, cuando creamos un objeto y definimos sus características (o incluso sin definirlas), ya podemos crear objetos de esa clase, gracias a que java construye un constructor por defecto.
Por consiguiente, si creamos un objeto y no creamos ningún método constructor, podemos decir que para construir un objeto, utilizamos el constructor por defecto.
Creación de constructores en java.
Aunque podemos usar el constructor por defecto, no suele ser recomendable en la mayoría de los casos. Por lo tanto, debemos crear un constructor que le dé un estado inicial a nuestro objeto.
Esto podemos hacerlo de diversas maneras.
Tipos de constructores en java.
El constructor sin parámetros.
En este caso vamos a crear un método constructor sin parámetros. Esto lo haremos de la siguiente manera.
public class Persona {
/* Caracteristicas o atributos del objeto. */
private String dni;
private String nombre;
private byte edad;
// Método constructor sin parámetros.
Persona(){
this.dni="";
this.nombre="";
this.edad=0;
}
}
En este caso al crear un objeto persona desde el método main, lo haremos de igual forma que lo hicimos antes. Sin embargo, ahora se le dará un estado inicial a esta persona con los valores que hemos definido en el constructor.
- El DNI y el nombre tendrán una cadena vacía, ya que son datos de tipo String.
- La edad será una edad inicial de cero años.
Constructor con parámetros.
Los constructores de una clase también pueden recibir entre sus paréntesis, parámetros o argumentos para darle a un objeto un estado inicial. Vamos a ver un ejemplo.
package objetos;
public class Personal {
private String dni;
private String nombre;
private int edad;
public Personal(String dni, String nombre, int edad) {
this.dni = dni;
this.nombre = nombre;
this.edad = edad;
}
}
En este caso, cuando vayamos a crear un objeto de la clase persona, le debemos pasar al objeto unos valores entre los paréntesis del constructor.
Como ya hemos dicho varias veces, lo que haya a la derecha del igual, se asignará a la parte izquierda del igual, por lo tanto:
- El argumento dni que se pasa en el constructor, se asignará a la variable dni y será un valor de tipo texto.
- El argumento nombre que se pasa en el constructor, se asignará a la variable nombre y será un valor de tipo texto.
- Por otro lado, el argumento edad que se pasa en el constructor, se asignará a la variable edad y será un valor de tipo número entero.
Sobrecarga de métodos en java.
Cuando creamos clases u objetos en java podemos tener lo que llamamos sobrecarga de métodos constructores o de cualquier otro tipo.
Esta sobrecarga, lo que hace es dotar a nuestro objeto de más funcionalidad. Solo debemos tener en cuenta que para que la sobrecarga de métodos sea valida deben cumplirse dos condiciones:
- Los métodos deben tener el mismo nombre.
- Deben recibir diferente número de parámetros.
- Si recibe el mismo número de parámetros, estos deben ser de diferente tipo.
Ejemplo de sobrecarga de métodos constructores.
package objetos;
public class Persona {
/* Caracteristicas o atributos del objeto. */
private String dni;
private String nombre;
private int edad;
// Métodos constructores.
Persona(){
this.dni="";
this.nombre="";
this.edad=0;
}
/* Constructor que recibe 3 parámetros que el
* usuario le pasará por teclado*/
Persona(String pDni, String pNombre, int pEdad){
this.dni=pDni;
this.nombre=pNombre;
this.edad=pEdad;
}
/* Constructor que recibe 2 parámetros que el
* usuario le pasará por teclado*/
Persona(String pDni, String pNombre){
this.dni=pDni;
this.nombre=pNombre;
this.edad=0;
}
/* Constructor que recibe 1 parámetro que el
* usuario le pasará por teclado*/
Persona(String pDni){
this.dni=pDni;
this.nombre="";
this.edad=0;
}
}
Como crear objetos de tipo persona con constructores con parámetros.
En este ejemplo vamos a crear cuatro objetos persona. Un objeto persona con cada constructor.
package objetos;
public class Principal {
public static void main(String[] args) {
/* Creamos un objeto persona llamado persona1
* con el constructor sin parámetros*/
Persona persona1 =new Persona();
/* Creamos un objeto persona llamado persona2
* con el constructor pasandole 3 parámetros
* El DNI, el nombre y la edad*/
Persona persona2 =new Persona("12345678X","Fran",35);
/* Creamos un objeto persona llamado persona3
* con el constructor pasandole 2 parámetros
* El DNI y el nombre*/
Persona persona3 =new Persona("12345678X","Fran");
/* Creamos un objeto persona llamado persona4
* con el constructor pasandole 1 parámetros
* El DNI*/
Persona personaTres =new Persona("12345678X");
}
}
El constructor copia en java.
El constructor copia es un tipo de constructor que recibe como parámetro un objeto de la misma clase. Es decir, en este caso estamos creando objetos de tipo persona, por lo que el constructor recibirá por parámetro un objeto de este tipo. Veamos entonces un ejemplo donde se muestran los tres tipos de constructores.
package objetos;
public class Persona {
private String dni;
private String nombre;
private int edad;
// Constructor sin parámentros
public Persona() {
this.dni = "";
this.nombre = "";
this.edad = 0;
}
// Constructor con parámentros
public Persona(String dni, String nombre, int edad) {
this.dni = dni;
this.nombre = nombre;
this.edad = edad;
}
// Constructor copia
public Persona(Persona objPersona){
// pasamos a cada variable lo que contiene
// el cada persona...
this.dni=objPersona.dni;
this.nombre=objPersona.nombre;
this.edad=objPersona.edad;
}
}
Y ahora por tanto en el método main, podemos crear una persona y crear con este constructor copia una copia de ese mismo objeto. Vamos a ver un ejemplo.
package objetos;
public class Principal {
public static void main(String[] args) {
// Creamos tres variables que contendrán el dni
// el nombre y la edad de la persona
String valorDNI, valorNombre;
int valorEdad;
valorDNI="999777555N";
valorNombre="María";
valorEdad=22;
// Creamos un objeto de tipo persona.
// Entre los paréntesis del constructor
// se pasan estas variables.
Persona miPersona=new Persona(valorDNI,valorNombre,valorEdad);
// Creamos una copia del objeto miPersona.
Persona copiaPersona=new Persona(miPersona);
}
}
Destrucción de objetos en java.
En algunos lenguajes de programación, para destruir un objeto, existen varios métodos o funciones que se ejecutan de forma automática para destruirlo. Esta función no devuelve ningún valor, (por lo tanto es de tipo void), y no recibe ningún parámetro.
Por otro lado, es importante destacar que en java no existen destructores. Java es un lenguaje que posee un recolector de basura (garbage collector). Este recolector de basura, ejecuta automáticamente un método llamado finalize(). Por lo tanto, cuando un programa java ya no está utilizando un objeto se realizan dos acciones:
- Por un lado entra en acción de forma automática el garbage collector.
- Este recolector de basura llama al método finalize() y lo ejecuta.
- Para finalizar, se destruye el objeto y se liberan los recursos utilizados en la memoria RAM del ordenador.
Para finalizar, debes conocer también a grandes rasgos que es la clase Object.
Clase Object en java.
También es llamada como clase cósmica, ya que la clase Object, es la clase que está por encima de todas las clases de la api de java.
Esto quiere decir que todas las clases de java que vienen predefinidas en el lenguaje de programación, como las que nosotros construimos, heredan de la clase object.