Coche cocheRojo = new Coche();
La sentencia anterior crea un cocheRojo de la clase Coche, es decir, un objeto de la clase cocheRojo.
En primer lugar se crea la variable cocheRojo de la clase Coche, luego en segundo lugar se referencia con la palabra clave new, al método constructor. Cada vez que creamos un objeto se hace la llamada al método constructor de dicha clase. El método constructor tiene el mismo nombre de la clase y es un método que no devuelve ningún tipo de valor. Por eso después de utilizar new ponemos la misma palabra de la clase, porque se llama al método constructor. El método constructor, si no tiene parámetros se pone los paréntesis vacíos como con cualquier otro método sin parámetros.
Todo esto puede parecer muy lioso al principio pero, la teoría en programacón es así, lo veréis todo mejor cuando pongamos los ejemplos.
Nos podemos preguntar, si cuando hemos visto cómo se creaban las clases en Java no hemos creado ningún método constructor. ¿Cómo es que cuando se crea un objeto tenemos que llamar al método constructor? Esto es porque si cuando creamos una clase, y esa clase no creamos un método constructor, cuando se cree una instancia de esa clase Java crea un método constructor por defecto sin parámetros. Por eso cuando creamos un objeto siempre hay que llamar al método constructor aunque no hayamos creado ninguno, porque Java llamará al constructor por defecto, es decir al constructor de la clase sin parámetros.
Bueno, después de este royaco que he metido vamos a lo importante. ¿Para qué sirve un método constructor?
Un método constructor sirve para inicializar un objeto con unos valores iniciales. En el siguiente ejemplo crearemos una clase, y en dicha clase crearemos nuestro método constructor y veremos cómo funciona:
public class Persona {
//Atributos
private String nombre;
private String apellidos;
private int edad;
private String trabajo;
//Ahora crearemos nuestro método constructor. Como hemos dicho un método
//Constructor sirve para inicializar valores de un objeto concreto.
//por lo que vamos a crear un constructor que inicialice los valores de los
//atributos.
//Un constructor tiene el mismo nombre de la clase, y entre paréntesis
//le pasamos los parámetros que queremos inicializar.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//De esta forma, cuando instanciemos un objeto de esta clase Persona
//y llamemos al constructor debemos pasarlo como parámetros nombre,
//apellidos, edad y trabajo que tomará los valores que le pasemos
//para ese objeto concreto
//Métodos get para recuperar la información. En este ejemplo no vamos a
//crear los métodos set porque no nos van a hacer falta
public String getNombre(){
return nombre;
}
public String getApellidos(){
return apellidos;
}
public int getEdad(){
return edad;
}
public String getTrabajo(){
return trabajo;
}
}
Ahora vamos a crear un par de instancias de la clase Persona para observar cómo trabaja el método constructor. El siguiente código muestra la clase Programa con las explicaciones necesarias:
public class Programa {
public static void main(String[] args) {
//Creamos dos objetos de la clase Persona.
/*
Como digimos después del new se llama al constructor. Si recordamos el
constructor de la clase Persona le pasamos como parámetros el nombre,
los apellidos, la edad y el nombre del trabajo. Ahora debemos poner los
argumentos en el mismo orden, es decir, primero el nombre, luego los
apellidos, la edad y por último el nombre del trabajo
*/
Persona yo = new Persona("Javier", "Pérez Rubio", 26, "Informático");
//En este objeto inicializamos los valores a los valores pasados como
//argumentos por el constructor. Ahora vamos a crear otro objeto
Persona otraPersona = new Persona("María", "De la Rosa", 21, "Administrativa");
//Para este objeto le hemos pasado otros valores. Ahora vamos a mostrar
//pantalla todos los valores de los dos objetos.
System.out.println("EL OBJETO YO TIENE EL NOMBRE: " + yo.getNombre()+
" DE APELLIDOS " + yo.getApellidos()+ ", Y TIENE UNA EDAD DE " +
yo.getEdad()+ " Y TRABAJA DE " + yo.getTrabajo());
System.out.println("EL OBJETO OTRAPERSONA TIENE EL NOMBRE: " + otraPersona.getNombre()+
" DE APELLIDOS " + otraPersona.getApellidos()+ ", Y TIENE UNA EDAD DE " +
otraPersona.getEdad()+ " Y TRABAJA DE " + otraPersona.getTrabajo());
}
}
Un método Constructor no devuelve ningún tipo de valor, ni siquiera se indica void. Simplemente el método constructor se forma con el nombre de la clase e indicando los parámetros, si lleva.
Si ejecutamos nos mostrará la siguiente imagen.
Hay que tener en cuenta que si no creamos un método constructor Java nos crea uno por defecto sin parámetros que inicializa los valores a los valores por defecto, 0 a los atributos de tipo int, null para los String, false para los boolean... Pero si creamos un método constructor Java ya no creará ningún constructor por nosotros, por lo que si creamos un objeto y para ese objeto hemos creado un constructor con parámetros y cuando instanciemos ese objeto y no le pasamos argumentos al método constructor nos dará un error de compilación, puesto que tendremos que introducir los argumentos que hayamos indicado a la hora de crear el constructor.
Si quisiéramos poder instanciar un objeto y no pasarle argumentos en el constructor deberemos de crearlo nosotros mismos, es decir, los métodos constructor aceptan la sobrecarga. ¿Que qué es la sobrecarga del método constructor? Lo vamos a ver a continuación:
SOBRECARGA DEL MÉTODO CONSTRUCTOR
En el tutorial anterior vimos que era posible la sobrecarga de métodos. Ahora veremos que también es posible hacer sobrecarga del método constructor. Podemos crear tantos métodos constructor como queramos siempre que sean distintos, es decir, su firma sea distinta. ¿Qué quiere decir que su firma sea distinta? Pues que el número de parámetros y/o el tipo de datos de esos parámetros serán distintos en cada método que se cree.En el siguiente ejemplo vamos a seguir con el ejemplo de la clase Persona, en esta clase vamos a crear un total de 3 métodos constructor.
public class Persona {
//Atributos
private String nombre;
private String apellidos;
private int edad;
private String trabajo;
//Método constructor sin parámetros. Este constructor iniciará cada dato
//a su valor por defecto
public Persona(){
}
//Método constructor que inicializa los atributos a los valores que le pasemos
//como argumentos cuando creemos una instancia de esta clase.
public Persona(String nombre, String apellidos, int edad, String trabajo){
this.nombre = nombre;
this.apellidos = apellidos;
this.edad = edad;
this.trabajo = trabajo;
}
//Método constructor que se le pasa como parámetro un objeto de la clase
//Persona. Esto significa que este objeto tendrá los mismos valores en
//los atributos que el objeto pasado como argumento.
public Persona(Persona b){
this.nombre = b.nombre;
this.apellidos = b.apellidos;
this.edad = b.edad;
this.trabajo = b.trabajo;
}
public String getNombre(){
return nombre;
}
public String getApellidos(){
return apellidos;
}
public int getEdad(){
return edad;
}
public String getTrabajo(){
return trabajo;
}
}
Ahora crear instancias de la clase Persona y utilizaremos los 3 métodos constructor para que veáis cómo trabajan según qué constructor utilicemos.
public class Programa {
public static void main(String[] args) {
//Creamos un objeto de la clase persona que utilizará el constructor
//sin parámetros. Como ya digimos si no indicamos ningún constructor a la
//hora de crear una clase Java nos crea un constructor por defecto que
//no tiene parámetros. Pero si creamos algún constructor y queremos también
//tener un constructor sin parámetros, deberemos de crearlo nosotros mismos
//como hemos hecho en la clase Persona. Java, al crear nosotros un
//constructor ya no crea por defecto ese constructor sin parámetros.
Persona primeraPersona = new Persona();
//Creamos ahora un objeto que utilizará un constructor que le pasamos
//como argumentos los valores que tendrá esa persona
Persona segundaPersona = new Persona("Jose Luís", "Gálvez Soriano",
30, "Cajero");
//Por último creamos un objeto que utiliza el constructor que se le pasa
//como argumento un objeto, el objeto que se le pase será el objeto
//creado anteriormente segundaPersonal.
Persona terceraPersona = new Persona(segundaPersona);
//Ahora vamos a mostrar por pantalla la información de estos 3 objetos
/*
Veremos que primeraPersona mostrará los datos por defecto, segundaPersona
mostrará los datos que le hemos pasado como argumentos y por último
la terceraPersona mostrará los mismos datos que segundaPersona
*/
System.out.println("PrimeraPersona- Nombre: " + primeraPersona.getNombre()+
" Apellidos: " + primeraPersona.getApellidos()+" Edad: " +
primeraPersona.getEdad()+" Trabajo: " + primeraPersona.getTrabajo());
System.out.println("SegundaPersona- Nombre: " + segundaPersona.getNombre()+
" Apellidos: " + segundaPersona.getApellidos()+" Edad: " +
segundaPersona.getEdad()+" Trabajo: " + segundaPersona.getTrabajo());
System.out.println("TerceraPersona- Nombre: " + terceraPersona.getNombre()+
" Apellidos: " + terceraPersona.getApellidos()+" Edad: " +
terceraPersona.getEdad()+" Trabajo: " + terceraPersona.getTrabajo());
}
}
Si ejecutamos nos mostrará los datos como en la siguiente imagen:
Bueno eso es todo sobre los constructores, como siempre os digo si tenéis alguna duda no dudéis en enviar un comentario, todos los comentarios serán respondidos.
Nos vemos!!!!!
Muchasm,muchas Gracias. Aclare muchas dudas. ¿Seguiras con mas blogs?
ResponderEliminarMuchas gracias por comentar. Sí, seguiré con más tutoriales, con más código fuente y muchas más cosas!!
Eliminar