sábado, 12 de noviembre de 2011

Constructores en Java

votar
   Parece una tontería y sin embargo, los constructores son de las cosas que más problemas causan a los programadores noveles.
   Los constructores sirven para crear nuevos objetos. Por ejemplo:
class Gata{
     public Gata( ){}
    Gata g = new Gata( );
}
   Bueno, en este ejemplo, no parece que un constructor parezca ser algo muy útil, y en muchas ocasiones, el programador no se molesta en escribirlo. Pero eso no significa que no esté ahí, porque si tú no lo escribes, el compilador siempre, siempre, siempre, pondrá el constructor por defecto, ya que si no, no sería posible crear ningún objeto. Así que, si escribimos esto:
class Gata{
    Gata g = new Gata( );
 }
el compilador interpretará esto:
class Gata{
    public Gata( ){
           super( );
    }
    Gata g = new Gata( );
}
   ¿Qué es eso de super( ); te estarás preguntando?. Bueno, todos los objetos en Java son parte de un enorme árbol genealógico. Todas las clases son descendientes, o subclases, de otra, aunque sólo sea de una, la madre de todas las clases: la clase Objeto. Cuando se ejecuta el constructor de una clase, ese constructor llama al constructor de su superclase, que también se ejecuta y a su vez llama al constructor de su superclase...y así hasta llegar a la clase Objeto. Ese super( ); es la llamada explícita al constructor de la superclase.
   ¿Y por qué hacer una llamada explícita si el compilador la hace por ti?. Supongamos este ejemplo:
class Mascota{
    private String nombre;
    public Mascota(String n){
        nombre = n;
    }
    public String getNonbre( ){
        return nombre;
    }
class Gata extends Mascota{
    public Gata( ){ }//escribes esto
       // super( ); pero es esto otro lo que hay en realidad    
}//Oh, oh, error de compilación.
   Efectivamente, el compilador hace una llamada al constructor por defecto de la superclase. El problema, es que la superclase y la clase no tienen el mismo constructor. El constructor por defecto no tiene argumentos, pero en este caso vemos que el constructor de Mascota tiene uno: String n.
   ¿Pero Mascota no tiene un constructor por defecto?. No, en el momento en que se escribe un constructor, el compilador no ve necesario añadir el constructor por defecto.
   Por supuesto, pueden coexistir varios constructores a la vez, así que si el programador escribe:
class Mascota{
    private String nombre;
    public Mascota(String n){
        nombre = n;
    }
    public Mascota( ){ }
    }
class Gata extends Mascota{
    public Gata( ){ }
}
el compilador no protestará porque puede llamar al constructor sin argumentos de la superclase. Veamos con   un ejemplo cómo funciona esta llamada a super( );
class Mascota{
    private String nombre;
    public String getNombre( ){
        return nombre;
    }
    public Mascota(String n){
        nombre = n;
        System.out.println("Esta es mi mascota");
}
class Gata extends Mascota{
    public Gata(String n){
        super(n);
    }
    public static void main(String[ ] args){
        Gata g = new Gata("Linda");
        System.out.println("El nombre de mi gata es " + g.getNombre();
    }
}
El resultado al ejecutar la clase Gata sería:
Esta es mi mascota
El nombre de mi gata es Linda
   Vemos que primero se ejecuta el constructor de la superclase y luego el de la clase.

   Además un constructor puede llamar a otro constructor de la misma clase usando this( ) Por ejemplo:
class Gata{
    String nombre;
    Gata(String n){
        nombre = n;
    }
    Gata( ){
        this("Bonita");
    }
    public static void main(String[ ] args){
        Gata g1 = new Gata("Linda");
        Gata g2 = new Gata( );
        System.out.println(g1);
        System.out.println(g2);
    }
}
   El constructor sin argumentos hace una llamada al primer constructor, que tiene un argumento de tipo String, y el resultado sería:
Linda
Bonita
   Tanto super( ) como this( ) deben usarse en la primera línea del constructor, pero no pueden usarse a la vez.

   Por último, no hay que confundir los constructores con los métodos. Los constructores siempre tienen el mismo nombre que la clase (y ningún programador que se precie escribiría un método con el nombre de la clase, aunque es factible), pero además, los constructores no tienen tipo de retorno, ni siquiera void, y los únicos modificadores que pueden usar son los de acceso.

   En fin, espero que este post os haya servido para clarificar algunas cosas respecto a los constructores.

2 comentarios:

  1. Muchas gracias por todas las clases, estoy agradecido de conocer está página, la encuentro muy buen, me ha ayudado a entender y recordar muchas cosas que pase en la Universidad y que hoy en día me sirven en el trabajo.

    Saludos.

    ResponderEliminar
    Respuestas
    1. Gracias por tu amable comentario, Jorge.
      Me alegro de que el blog te sea de utilidad.
      Un saludo.

      Eliminar