Bienvenidos a este nuevo y última clase de programación en java para principiantes, lógicamente este curso aún no se ha acabado, ya que es bastante mas largo, hasta el momento estás casi en la mitad del camino para convertirte en un experto prograador en java con netbeans, todas las clases a partir de aqui son del bloque intermedio / avanzado, hasta el momento, todo lo que hemos hecho en este curso es crear programas sin ningún tipo de interface gráfica, pero, dentro de no demasiadas clases empezaremos a ver como se crear los programas con interface gráfica y como los podemos programar, en este curso veremos los métodos constructor, que son métodos especiales que són llamados cada vez que definimos una instancia.

 

     Con método especial nos referimos por ejemplo a que un método constructor no se puede llamar de ninguna manera, por tanto, podemos decir que es un método especial que es llamado una única vez al utilizar una palabra clave que ya tendrias que conocer porque es la que utilizamos cada vez que queremos instanciar un objeto, esa palabra clave es la palabra clave new.

 

 

¿Que es lo que hace la palabra clave new?

 

- Localiza memoria automaticamente para la variable u objeto.

- Inicializa las variables.

- Llama al método constructor de la clase.

 

 

Por tanto un método constructor se ejecuta unicamente cuando se crea un objeto y no se puede llamar mas.

 

 

¿Qué ventajas presenta utilizar un método constructor?

 

     En primer lugar es que podemos inicializar nosotros mismos las variables en el caso de necesitarlo, de no ser así tambien se inicializan, pero con los valores por defector, es decir, null para los Strings, False para los boolean, 0 para los números y tambien podemos llamar a métodos de ese objeto para que tambien sea ejecutado automáticamente en el momento que se cree el objeto, y tambien podemos sobrecargar los metodos constructor pasandole los argumentos determinados y se lo pasamos en el new.

 

 

Entre un método regular y un método constructor hay principalmente 3 diferencias.

 

- Siempre va a tener el mismo nombre que el de la clase.

- No tiene tipo de retorno y por lo tanto no devuelve ningún valor.

- No podemos usar Return.

 

 

     Veamoslo en un ejemplo, primero crearemos la clase junto a tres varibles instancia, una de tipo String y dos de tipo int, y despues crearemos el método constructor.

 

 

class PizarraHistoria {
    String estatus;
    int numeroPregunta;
    int puntuacion;
    
    PizarraHistoria (String entrada1, int entrada2, int entrada3) {
        estatus = entrada1;
        numeroPregunta = entrada2;
        puntuacion = entrada3;
        
    }

    public static void main(String [ ] args) {
        PizarraHistoria grecia = new PizarraHistoria("activa", 3, 6);
        System.out.println(grecia.estatus);
        System.out.println(grecia.numeroPregunta);
        System.out.println(grecia.puntuacion);
        
    }

}

 

     Como podemos observar hemos creado el método constructor colocando el nombre de la clase y entre parentesis las variables y objetos que hemos decidido asignar al método constructor, y dentro de las llaves como siempre el cuerpo del método que en este caso ha sido igualar el valor de las variables instancia al de las variiables locales del método.

 

     Una clase puede tener mas de un construtor y java nos permite la comunicación entre diferentes métodos constructor, y para esto java nos proporciona una manera para hacer esto, manera muy similar a una que nosotros conocemos solo que un poco cambiada tal y como se muestra a continuación.

 

this(args1, args2, args3);

 

     Con args1, args2, y args3 nos estamos refiriendo como es lógico a los parametros que se requieren para llamar a un método constructor, solo que en este caso lo estamos haciendo desde dentro de otro método constructor.

 

 

 class Circulo {
    int x, y, radio;

    Circulo(int puntoX, int puntoY, int tamRadio) {
        this.x = puntoX;
        this.y = puntoY;
        this.radio = tamRadio;
       
    }
    Circulo(int puntoX, int puntoY) {
        this(puntoX, puntoY, 1);
       
    }
    void Resultado() {
        int resultado = x*y*radio;
        System.out.println(resultado);
    }
    public static void main (String [ ] args) {
        Circulo circulo = new Circulo(2,3,4);
        
    }
}

 

 

     Aqui podemos ver claramente lo que hace este código y tamebien lo qu hemos hecho en el código, lo que hemos hecho nada mas empezar ha sido crear la clase y tres variables de tipo int, despues hemos creado dos métodos constructor con argumentos distintos, en el primero con tres variables de tipo int que igualamos al valor delas variables de instancia y en el segundo método constructor definimos dos variables instancia como argumentos, recordemos que esto se llama sobrecarga de métodos tanto en los métodos normales como en los constructor, y a traves de la sintaxis this(puntoX, puntoY, 1) para definir el valor de la tercera variable como 1 y utilizar las variables del otro constructor en este, intenta razonar un poco y piensa en que es lo que puede hacer este código al ejecutarse.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Pues si tu respuesta ha sido que no hará nada estas en lo cierto, porque en ningun momento hemos hecho referencia al método Resultado() por lo tanto no hará nada, ahora cambiemoslo y llamemos la método Resultado en el segundo constructor.

 

 class Circulo {
    int x, y, radio;
    Circulo(int puntoX, int puntoY, int tamRadio) {
        this.x = puntoX;
        this.y = puntoY;
        this.radio = tamRadio;
       
    }
    Circulo(int puntoX, int puntoY) {
        this(puntoX, puntoY, 1);
        Resultado();
    }
    void Resultado() {
        int resultado = x*y*radio;
        System.out.println(resultado);
    }
    public static void main (String [ ] args){
        Circulo circulo = new Circulo(2,3,4);
        
    }
    
}

 

 

Intenta razonar un poco y piensa en que es lo que puede hacer este código al ejecutarse.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Pues si tu respuesta ha sido que no hará nada estas en lo cierto, porque al haberle pasado tres valores estamos haciendo referencia al primer constructor y en el primero de los constructor no hemos llamado al método resultado, asi que lo que vamos a hacer es llamarlo.

 

 class Circulo {
    int x, y, radio;
    Circulo(int puntoX, int puntoY, int tamRadio) {
        this.x = puntoX;
        this.y = puntoY;
        this.radio = tamRadio;
       
    }
    Circulo(int puntoX, int puntoY) {
        this(puntoX, puntoY, 1);
        Resultado();
    }
    void Resultado() {
        int resultado = x*y*radio;
        System.out.println(resultado);
    }
    public static void main (String [ ] args){
        Circulo circulo = new Circulo(2,3,4);
        
    }
    
}

 

 

Intenta razonar un poco y piensa en que es lo que puede hacer este código al ejecutarse.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

Pues si has dicho que imprimira la operación 2*3*4 esta vez si que estas en lo cierto.

 

 

Ahora dejamos de lado por un momento a los métodos constructores para centrarnos en los métodos en jeneral, como ya sabesmos de clases anteriores una clase hereda de su superclase todos los métodos y variables de su superclase, y tambien sabemos como busca java los métodos y demas, lo hace de abajo a arriva, y lo que vamos a ver ahora es como podemos sobreescribir un método, esto nos puede venir muy bien en el caso de que por ejemplo queramos que un método se comporte de manera distinta en un sitio que en otro, pues esto lo tenemos que hacer creando un método con la misma firma en la subclase y escribir un cuerpo del método distinto (el que nosotros necesitemos), y ya sabemos que con firma nos referimos al mismo nombre y el mismo número de argumentos. Veamoslo.

 

 

class Imprimir {
    int x = 0;
    int y = 1;
    
    void imprimeme() {
        System.out.println("x es: " + x + ", y es: " + y);
        System.out.println("Soy una instancia de la clase " +
                this.getClass().getName() );
        
    }
}

class SubImprimir extends Imprimir {
    int z = 3;
    
    
    public static void main(String [ ] args) {
        SubImprimir obj = new SubImprimir();
        obj.imprimeme();
    }
}

 

Como podemos ver en este ejemplo, hemos creado una clase llamada Imprimir con dos variables int x, y, y luego hemoos creado otra clase de nombre subimprimir y con la palabra clave extends la hemos hecho subclase de la clase Imprimir, por tanto, lo hereda todo de su superclase incluida el método imprimeme, y dentro de ella creamos una variable de nombre z y creamos un obj de la clase subimprimir de nombre obj y le damos a sift F6, y el resultado es este.

 

run:
x es: 0, y es: 1
Soy una instancia de la clase SubImprimir
GENERACIÓN CORRECTA (total time: 0 seconds)

 

 

Como podemos comprobar ejecuta el método correctamente, pero no nos muestra la variable z, por lo que queremos modificarla por lo que creamos un nuevo método en la clase subimprimir con la misma firma y le añadimos para que nos muestre la variable z, y así se queda:

 

 

class Imprimir {
    int x = 0;
    int y = 1;
    
    void imprimeme() {
        System.out.println("x es: " + x + ", y es: " + y);
        System.out.println("Soy una instancia de la clase " +
                this.getClass().getName() );
        
    }
}

class SubImprimir extends Imprimir {
    int z = 3;

    void imprimeme() {
        System.out.println("x es: " + x + ", y es: " + y + "y es: " + z);
        System.out.println("Soy una instancia de la clase " +
                this.getClass().getName() );
        
    }
    
    public static void main(String [ ] args) {
        SubImprimir obj = new SubImprimir();
        obj.imprimeme();
    }
}

 

run:
x es: 0, y es: 1, z es: 3
Soy una instancia de la clase SubImprimir
GENERACIÓN CORRECTA (total time: 0 seconds)

 

 

NOTA: Hemos utilizado this.getClass().getName(); para que obtubiesemos el nombre de la clase a la que pertenece.

 

 

     Ahora vamos a ver una palabra clave, que creo que ya ha salido en una clase anterior y no habiamos explicado para que servía, esa es la palabra clave SUPER, esta palabra clave sirve para llamar al método de una superclase y para añadir mas atributos y por el estilo en vez de reemplazarlo por completo que es lo que habiamos hecho antes, bueno, usamos la palabra clave super para llamar al método original desde dentro de un método.

 

 

1º | En superclase:

 

void HacerMetodo(String a, String b) {

    //Cuerpo del método

}

 

 

2º | En subclase:

 

void HacerMetodo(String a, String b) {

    super.HacerMetodo(a, b);

    //Cuerpo del método

}

 

 

     De este método recopilamos en la subclase toda la información del método de la superclase y a partir de ay, ya podemos ampliar todo el contenido que queramos, la palabra clave super es equivalente a la palabra clave this solo que este es para referirse al de la superclase.

 

     Tecnicamente los constructores no pueden ser sobreescritos porque deben llamarse siempre como su clase, asi que lo que tenemos que hacer para "sobrescribirlo", es llamar explicitamente de alguna manera al constructor de su superclase para desde allí, poder modificarlo, pues para ello contamos con la palabra clave super, en java, para llamar a un método constructor explicitamente desde la superclase a traves de la palabra clave super, ya que no se le puede llamar con ningún nombre, es la siguiente.

 

super(argumentos);

 

 

     Ay que tener muy encuenta una regla que tiene java para utilizar la palabraclave super, en java super() siempre debe ser la primera declaración en la definición de nuestro constructor.

 

Veamoslo en un ejemplo, primero importaremos la clase Point y crearemos una clase que sea subclase de la clase Point y modificaremos su constructor.

 

 

import java.awt.Point;

class NombrePunto extends Point {
    String nombre;
    
    NombrePunto(int x, int y, String nombre) {
        //Super se utiliza para que el valor de las variables x e y
        //sean iguales al valor de la x e y de la clase Point
        super(x,y);
        this.nombre = nombre;
        
        
    }
    
    public static void main (String [ ] args) {
        NombrePunto np = new NombrePunto(5, 5, "Punto de Encuentro");
        System.out.println("x es: " + np.x);
        System.out.println("y es: " + np.y);
        System.out.println("Nombre es: " + np.nombre);
    }
   
}

 

 

Y como siempre, razona tu mismo que es lo que hace este código, y ya de paso te recuerdo que la mejor forma de aprender a programar es revisando código y haciendolo tu mismol y hasta aqui la última clase para principiantes de este curso.