MÉTODO CONSTRUCTOR
Que es?
Un método constructor es un método especial de una clase que se invoca siempre que se crea un objeto de esa clase.
Características:
- Tienen el mismo nombre de la clase.
- No devuelven ningún valor
- debe declararse como "public"
Los métodos públicos no se ponen ningún valor de retorno; como antes escribíamos "public void", "public int", etc; pero en los constructores solo se colocan "public".
Realizaremos un ejemplo:
package Simple;
public class Persona{
//Atributos
String nombre;
int edad;
//Metodos
//metodo Constructor
public Persona(String Nombre, int Edad){
nombre = Nombre;
edad = Edad;
}
public void mostrarDatos(){
System.out.println("El nombre es: "+nombre);
System.out.println("La edad es: "+edad);
}
public static void main (String[] args){
Persona p1 = new Persona("Daniel",21);
p1.mostrarDatos();
}
}
Listo como vemos hemos creado un constructor "Persona" (mismo nombre de la clase) y le asignamos parámetros, uno de tipo String y otro de tipo int. Ahora crearemos un método para mostrar los datos y por ultimo, crearemos una clase o en la misma clase crear el método main y crear un objeto p1 pero saldra un error por que "Persona" ya existe, es un método constructor que tiene 2 parámetros uno es "String" y el otro es "int" y por lo tanto escribiremos asi: "Persona p1 = new Persona("Daniel",21);" .
Que es lo que hace?
Lo que hace es primero llamar al constructor "Persona" y "Daniel" es un String y esta guardando en la variable "Nombre" y 21 en la variable "Edad" y después la Variable "Nombre" se esta guardando en el atributo "nombre" así como de "Edad" a "edad" y después va a imprimir, Al ejecutar el programa nos imprimirá así:
Esa es una forma de crear constructores, existe otra forma de crear los constructores y es muy utilizada; usaremos el ejemplo anterior:
public Persona(String Nombre, int Edad){
nombre = Nombre;
edad = Edad;
}
Vamos a escribir las variables del mismo nombre de los Atributos de esta manera:
public Persona(String nombre, int edad){
nombre = nombre;
edad = edad;
}
Al ejecutar no sale de esta forma:
La pregunta es; Por que nos aparece así? si le colocamos parámetros en el constructor!! es porque JAVA se confunde y no sabe que enviar y para eso escribiremos una palabrita muy comun que es el "this" y nos quedaria de la siguente manera:
public Persona(String nombre, int edad){
this.nombre = nombre;
this.edad = edad;
}
Esta es la otra forma de crear constructores y al ejecutar nos aparece así:
El nombre es: Daniel
La edad es: 21
Pero porque con el "this" es porque al poner this le estas diciendo a JAVA que this pertenece o es el atributo que hemos declarado y el que no tiene el this, pertenece al parámetro del constructor.
Podemos hacer una sobrecarga de métodos de la siguiente forma:
Usaremos el mismo ejemplo:
Tenemos declarado las 2 variables: String nombre; int edad;
vamos a generar codigos haciendo click derecho y click en "insert code" y click en constructor y marcar los 2 ckecks o "select all" (si es que queremos generar todos) y "generade" y listo.
Si creamos una variable mas un String dni; y hacemos de la misma manera (ahora marcar check en dni) y generamos el constructor:
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public Persona(String dni) {
this.dni = dni;
}
Los Constructores "Persona" son lo mismo, pero, No debería marcar Error, si son los mismos métodos "Persona" ? es cierto que son métodos iguales pero lo que los diferencia son los parámetros. Los parámetros siempre van a diferenciar cualquier método siempre y cuando los parámetros se diferencien, También podemos hacer la sobre Carga con los Métodos, de la siguiente manera:
public void correr(){
System.out.println("Soy "+nombre+" y Tengo"+edad);
}
public void correr(){
}
Pero si hacemos esto, No debería marcar error? Como he mencionado, lo que diferencia los métodos son los parámetros así que colocaremos un parámetro, así:
public void correr(){
System.out.println("Soy "+nombre+" y Tengo"+edad);
}
public void correr(int km){
System.out.println("Corri unos "+km);
}
Ahora si hacemos así, que ocurriría:
public void correr(int km){
System.out.println("Soy "+nombre+" y Tengo"+edad);
}
public void correr(int km){
System.out.println("Corri unos "+km);
}
Nos marcaría error, por que como mencione siempre y cuando los parámetros se diferencien así que le parece si en vez de un int le colocaremos un double, marcaría error? pues ya no por que ya es otro parámetro. ahora con el método main haremos esto:
Persona p1 = new Persona();
Al hacer esto, nos pedirá uno de los 2 constructores y seleccionaremos el que tiene 2 parámetros, quedaría así:
Persona p1 = new Persona("Daniel", 21); //luego usaremos el primer metodo (el que no tiene parametro) ya que en el segundo tenemos que ingresar el dato: p1.correr();
cremos un 2do objeto: Persona p1 = new Persona("76544533"); //usaremos el 2do constructor(String dni), luego llamamos al segundo metodo: p2.correr(100); y listo esto seria todo.
