Constructor en Java

Un constructor es un método especial de una clase que se llama automáticamente siempre que se declara un objeto de esa clase.
Su función es inicializar el objeto y sirve para asegurarnos que los objetos siempre contengan valores válidos.

Cuando se crea un objeto en Java se realizan las siguientes operaciones de forma automática:
1.  Se asigna memoria para el objeto.
2. Se inicializan los atributos de ese objeto con los valores predeterminados por el sistema.
3. Se llama al constructor de la clase que puede ser uno entre varios.
El constructor de una clase tiene las siguientes características:

Tiene el mismo nombre que la clase a la que pertenece.

En una clase puede haber varios constructores con el mismo nombre y distinto número de argumentos (se puede sobrecargar)

No se hereda.

No puede devolver ningún valor (incluyendo void).

Debe declararse público (salvo casos excepcionales) para que pueda ser invocado desde cualquier parte donde se desee crear un objeto de su clase.
MÉTODO CONSTRUCTOR POR DEFECTO
Si para una clase no se define ningún método constructor se crea uno automáticamente por defecto.
El constructor por defecto es un constructor sin parámetros que no hace nada. Los atributos del objeto son iniciados con los valores predeterminados por el sistema.
Por ejemplo, en la clase Fecha:
import java.util.*;

public class Fecha {

    private int dia;
    private int mes;
    private int año;
  
    private boolean esBisiesto() {
        return ((año % 4 == 0) && (año % 100 != 0) || (año % 400 == 0));
    }

    public void setDia(int d) {
       dia = d;
    }

    public void setMes(int m) {
        mes = m;
    }

    public void setAño(int a) {
        año = a;
    }

    public void asignarFecha() {
        Calendar fechaSistema = Calendar.getInstance();
        setDia(fechaSistema.get(Calendar.DAY_OF_MONTH));
        setMes(fechaSistema.get(Calendar.MONTH));
        setAño(fechaSistema.get(Calendar.YEAR));
    }

    public void asignarFecha(int d) {
        Calendar fechaSistema = Calendar.getInstance();
        setDia(d);
        setMes(fechaSistema.get(Calendar.MONTH));
        setAño(fechaSistema.get(Calendar.YEAR));
    }

    public void asignarFecha(int d, int m) {
        Calendar fechaSistema = Calendar.getInstance();
        setDia(d);
        setMes(m);
        setAño(fechaSistema.get(Calendar.YEAR));
    }

    public void asignarFecha(int d, int m, int a) {
        setDia(d);
        setMes(m);
        setAño(a);
    }

    public int getDia() {
        return dia;
    }

    public int getMes() {
        return mes;
    }

    public int getAño() {
        return año;
    }

    public boolean fechaCorrecta() {
        boolean diaCorrecto, mesCorrecto, anyoCorrecto;
        anyoCorrecto = (año > 0);
        mesCorrecto = (mes >= 1) && (mes <= 12);
        switch (mes) {
            case 2:
                if (esBisiesto()) {
                    diaCorrecto = (dia >= 1 && dia <= 29);
                } else {
                    diaCorrecto = (dia >= 1 && dia <= 28);
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                diaCorrecto = (dia >= 1 && dia <= 30);
                break;
            default:
                diaCorrecto = (dia >= 1 && dia <= 31);
        }
        return diaCorrecto && mesCorrecto && anyoCorrecto;                                         
    }
}
no se ha definido ningún constructor, por lo que al declarar un objeto el compilador utilizará un constructor por defecto.
En este caso el método constructor por defecto es:
Fecha() { }
Vamos a añadir un constructor a la clase Fecha para poder iniciar los atributos de los nuevos objetos con valores determinados que se envían como parámetros. Si los valores corresponden a una fecha incorrecta se asigna la fecha del sistema:

public Fecha(int d, int m, int a) {
        dia = d;
        mes = m;  
        año = a;

        if (!fechaCorrecta()) {
            Calendar fechaSistema = Calendar.getInstance();
            setDia(fechaSistema.get(Calendar.DAY_OF_MONTH));                                       
            setMes(fechaSistema.get(Calendar.MONTH));
            setAño(fechaSistema.get(Calendar.YEAR));
        }
}
Con este método constructor podremos crear objetos de la siguiente manera:
Fecha fecha1 = new Fecha(10,2,2011);
Se crea un objeto fecha1 y se le asignan esos valores a sus atributos.
Si se crea un objeto con una fecha no válida:
Fecha fecha2 = new Fecha(10,20,2011);
A dia, mes y año se les asignará los valores del sistema.
Java crea un constructor por defecto si no hemos definido ninguno en la clase, pero si en una clase definimos un constructor ya no se crea automáticamente el constructor por defecto, por lo tanto si queremos usarlo deberemos escribirlo expresamente dentro de la clase.
En este ejemplo hemos definido un método constructor por lo que también es necesario poner el método constructor por defecto.
public Fecha(){}
Este constructor se invocará cuando se declare un objeto sin parámetros.
La clase tiene ahora dos constructores por lo que podemos crear objetos Fecha de dos formas:
Fecha f1 = new Fecha();   //se ejecuta el constructor sin parámetros
Fecha f2 = new Fecha(1,1,2010); //se ejecuta el constructor con parámetros
INVOCAR A UN MÉTODO CONSTRUCTOR
Un constructor se invoca cuando se crea un objeto de la clase mediante el operador new.
Si es necesario invocarlo en otras situaciones, la llamada a un constructor solo puede realizarse desde dentro de otro constructor de su misma clase y debe ser siempre la primera instrucción.
Si tenemos varios métodos constructores en la clase, podemos llamar a un constructor desde otro utilizando this.
Por ejemplo, si en el constructor con parámetros de la clase Fecha fuese necesario llamar al constructor sin parámetros de la misma clase escribimos:
public Fecha(int d, int m, int a) {
         this();  //llamada al constructor sin parámetros                                          
         dia = d;
         ……………
}
CONSTRUCTOR COPIA
Se puede crear un objeto a partir de otro de su misma clase escribiendo un constructor llamado constructor copia.
Este constructor copia los atributos de un objeto existente al objeto que se está creando.
Los constructores copia tiene un solo argumento, el cual es una referencia a un objeto de la misma clase que será desde el que queremos copiar.
Por ejemplo, para la clase Fecha podemos escribir un constructor copia que permita crear objetos con los valores de otro ya existente:
Fecha fecha = new Fecha(1,1,2011);   //se invoca al constructor con parámetros
Fecha fecha1 = new Fecha(fecha);  //se invoca al constructor copia
El constructor copia que escribimos para la clase es:
//constructor copia de la clase Fecha                                                              
public Fecha(final Fecha f) {
        dia = f.dia;
        mes = f.mes;  
        año = f.año;
}
El constructor copia recibe una referencia al objeto a copiar y asigna sus atributos uno a uno a cada atributo del objeto creado.
Declarar el parámetro como final no es necesario pero protege al objeto a copiar de cualquier modificación accidental que se pudiera realizar sobre él.

32 comentarios:

  1. ¿Hay alguna manera de tener los argumentos por defecto de un constructor?

    En C y C++ es igualando a un valor en el prototipo de la funcion ya sea constructor o método, pero en Java esto no vale.

    Un saludo

    ResponderEliminar
    Respuestas
    1. Si te refieres a hacer algo así como en C++

      int sumaTresNumeros(int a = 1, int b = 1, int c = 1);


      En java esto no se puede hacer, no podemos utilizar parametros con valores por defecto.

      Un saludo y gracias por visitar mi blog.

      Eliminar
  2. import javax.swing.JOptionPane;
    class constructor {
    private int n1=0;
    private int n2=0;
    public constructor (int n1, int n2){
    this.n1=n1;
    this.n2=n2;
    }
    public int sumas(){//ES UNA FUNCION
    int suma=0;
    suma=n1+n2;
    return suma;
    }

    }
    public class EjemploCONSTRUCTOR {

    public static void main(String[] args) {
    int nn1=0;
    int nn2=0;
    nn1=Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
    nn2=Integer.parseInt(JOptionPane.showInputDialog("Ingrese un numero: "));
    constructor ctr=new constructor( nn1 , nn2);
    JOptionPane.showMessageDialog(null,ctr.sumas());

    }
    }

    ResponderEliminar
  3. Muchas gracias por la explicación, clara, concisa y buenos ejemplos.

    ResponderEliminar
  4. Excelente!!!, en este sitio soft-mas.com tambien encontre buen material!!

    ResponderEliminar
  5. Saludos... Pregunta puede llamar desde el constructor sin argumento a otros dos. Ejemplos desde mi constructor
    public Fecha(){
    this(12,12,2012);
    this(12,2012); //este seria otro constructor con dos parametros
    }

    ResponderEliminar
    Respuestas
    1. Hola Miguel, la instrucción this debe ser la primera que aparezca, por lo tanto no se pueden poner 2 ya que el segundo this sería la segunda instrucción. Si necesitas hacer eso, puedes llamar al constructor con tres parámetros y dentro de éste hacer la llamada al constructor con dos parámetros.

      Eliminar
  6. Hola gente, les hago una consulta.
    Tengo en una clase esta variable y sus set y get
    private String administrador;

    public void setAdministrador(String admin)
    {
    this.administrador=admin;
    }

    public String getAdministrador(){
    return administrador;
    }

    y quiero pasarle parámetros desde un método para tomarlos en un form aparte pero no me funciona.
    public void verificarAdministrador(String admin,String pass,int nivel) throws ClassNotFoundException
    {
    setAdministrador(admin);

    }

    ResponderEliminar
  7. Hola Enrique, te tomo como fuente para el articulo, muchas cosas no las pude re editar ya que la forma que encontrastes estaban muy claras, pero puse para mi gusto ejemplos mas sencillos.
    Saludos!
    Te dejo el link al post: http://java-white-box.blogspot.com.ar/2013/12/javaplayer-constructores-en-java-que-es.html

    ResponderEliminar
  8. Gracias me has ayudado con los constructores

    ResponderEliminar
  9. Que pasa si el bloque de acciones de un constructor se deja vacío, y luego se invoca a ese constructor

    ResponderEliminar
  10. Identidad.
    Primer nombre y apellido.
    Fecha de ingreso.
    Sueldo.
    Incluya métodos para calcular las deducciones: Seguro Social, Cooperativa, Rap, Total Deducciones y Sueldo Neto.
    Utilice los métodos del inciso anterior para consolidar el método toString().
    Cree una aplicación con no menos de 5 instancias de la clase. Los datos deben ser introducidos por el usuario y liste en forma de tabla los datos de cada instancia. Muestre la información en la GUI de Java.

    ResponderEliminar
  11. alguien me ayuda tengo 15 ejercios pa hacer y no c bien como

    ResponderEliminar
  12. disculpen en los programas me piden la clase principal lo que es la linea public static void main (String []args){
    y yo le pongo la linea y me salen muchos errores en el programa no le entiendo a los constructores ayuds???

    ResponderEliminar
  13. disculpen en los programas me piden la clase principal lo que es la linea public static void main (String []args){
    y yo le pongo la linea y me salen muchos errores en el programa no le entiendo a los constructores ayuds???

    ResponderEliminar
    Respuestas
    1. Buen dia Manuel
      Los metodos constructores no se deben declarar en la clase ejecutable, debes crear otra clase en el mismo paquete, pero que no tenga el "public static void main (String []args){}". alli podrás declarar los atributos, y toda clase de metodos.

      Eliminar
  14. Excelente informacion, me has ayudado muchisimo. Grace

    ResponderEliminar
  15. Muchas Gracias amigo, de verdad me has ayudado. Agustin

    ResponderEliminar
  16. Cree una clase llamada Fecha, que incluya tres piezas de información como variables de instancia —un mes
    (tipo int), un día (tipo int) y un año (tipo int). Su clase debe tener un constructor que inicialice las tres variables
    de instancia, y debe asumir que los valores que se proporcionan son correctos. Proporcione un método establecer y un
    método obtener para cada variable de instancia. Proporcione un método mostrarFecha, que muestre el mes, día y año,
    separados por barras diagonales (/). Escriba una aplicación de prueba llamada PruebaFecha, que demuestre las capacidades
    de la clase Fecha.

    alguien que me ayude

    ResponderEliminar
  17. GRACIAS POR TU APORTE ES GENIAL ESTE BLOG ME HAS SALVADO EL SEMESTRE !!!!

    ResponderEliminar
  18. Qué es un constructor con parámetros en java

    ResponderEliminar
  19. public class NewMain {

    public static void main(String[] args) {
    /*Creamos un objeto CuentaCorriente para probar la clase y realizar
    algunas operaciones de ejemplo.*/
    CuentaCorriente c;

    c = new CuentaCorriente("Pepe", "13121545");//Cuenta corriente para Pepe
    //con DNI 13121545

    c.limite = -100; //establecemos el límite máximo de un retiro

    c.ingreso(1000);//ingresamos 1000 Quetzales
    c.egreso(300);//sacamos 300 Quetzales. Quedará 700 Quetzales
    c.mostrarInformacion();//mostramos

    System.out.println("Puedo sacar Q.700: " + c.egreso(700));//quedan 0 Q.
    System.out.println("Puedo sacar Q.500: " + c.egreso(500));//no es posible
    }

    }

    ResponderEliminar
  20. public class CuentaCorriente {
    double saldo; //efectivo disponible en la cuenta
    String nombre; //del titular
    String dni; //del titular
    double limite; //Cantidad de dinero que permite sacar de una cuenta

    /*Los parámetros de entrada: nombre y dni, ocultan a los atributos de la
    clase con el mismo identificador. Para acceder a ellos hay que utilizar this*/
    CuentaCorriente(String nombre, String dni){
    saldo = 0; // asignamos el saldo por defecto
    this.nombre = nombre; //nombre pasado como parámetro
    this.dni = dni; //DNI pasado como parámetro
    limite = -50; //límite del descubierto por defecto
    }

    boolean egreso(double cant){//sacar dinero de la cuenta corriente
    boolean operacionPosible;

    if((saldo - cant) >= limite){//si solicitamos sacar dinero dentro
    //del límite
    saldo -= cant; //no se permite realizar la operación.
    operacionPosible = true;
    }else{
    System.out.println("No hay dinero suficiente");
    operacionPosible = false;
    }
    return operacionPosible; //Indica si ha sido posible realizar la operacion
    }

    //Añadimos dinero a la cuenta corriente
    void ingreso(double cant){
    saldo += cant;
    }

    //Muestra el estado de la cuenta corriente
    void mostrarInformacion(){
    System.out.println("Nombre: " + nombre);
    System.out.println("Dni: " + dni);
    System.out.println("Saldo: " + saldo);
    System.out.println("Límite descubierto: " + limite);
    }
    }

    ResponderEliminar
  21. Soy nuevo en el lenguaje de Java, comparto un ejercicio que he encontrado!!

    ResponderEliminar
  22. que sucede si se elimina el constructor por defecto de la clase

    ResponderEliminar
  23. Yo que se sepa si se puede heredar un metodo constructor, mediante "extends" y "super"...

    ResponderEliminar
  24. disculpa soy nueva en esto de poo y no le entiendo muy bien a el metodo contructor me dirian como hacer este programa para que corriera bien lo intento y no corre.
    Realizar un programa que utilice método constructor para calcular la formula general y obtener
    X1 y X2
    Fórmula general
    X1=-b+sqrt((b 2 -4ac)/2a)
    )
    X2=-b-sqrt((b 2 -4ac)/2a)

    ResponderEliminar
  25. como es que puedo ejecutarlo, como se escribiría el main

    ResponderEliminar
  26. public class PrincipalTestHerenciaPersonaEstudianteTrabajador {
    public static void main (String [] args){
    int MAX = 10;
    int n =0;
    Persona p [];
    p = new Persona [MAX];
    //Objetos de tipo persona
    p [n++] = new Persona("12345", "Ariel", "Aldana", 'M', "Mexico",21);
    p [n++] = new Persona("54321", "Andrea", "Acosta", 'F', "Mexico", 21);

    //Objetos de tipo estudiante
    p [n++] = new Estudiante ("09876", "Juan", "Perez", 'M', "Masachusets", 34, "MIT", "Cuarto");
    p [n++] = new Estudiante ("67890", "Sofia", "Hernandez", 'F', "Madrid", 24, "IPM", "Quitnto");

    //Objetos de tipo trabajador
    p [n++] = new Trabajador ("13579", "Martin", "Escalante" , 'M',"Guadalajara" ,35 ,"Ingeniero", "$12,000");
    p [n++] = new Trabajador ("24680", "Ana", "Muñoz" , 'F',"Juarez" ,26 ,"Administradora", "$11,000");

    p [n++] = new Estudiante (p[2]); /*El error lo marca en esta línea. Observe que el objeto [2] del array invoca al constructor 'Estudiante */

    ResponderEliminar
  27. JOptionPane es para mostrar el resultado,

    ResponderEliminar