Introducción a Java

• Identificadores especiales
• null
• this
• super

Identificadores especiales

Existen un par de identificadores especiales que vamos a estudiar a continuación.

 null

Este identificador es la referencia nula. Es decir, cuando tenemos una referencia a un objeto, no queremos aún asignarle uno, pero deseamos utilizar esa variable deberemos igualarla a null:

public class Nulo {
  public static void main(String[] args) {
    String cad = null;
    if (cad == null)
      System.out.println("Es nulo");
  }
}

Como Java es un lenguaje seguro, si no inicializamos la referencia cad e intentamos acceder a ella nos dará un error de compilación. Esto tiene una excepción: cuando creamos un vector todos sus elementos se autoinicializarán a null. Esto es debido a que en compilación Java no tiene manera de saber qué elementos están inicializados y cuales no, por lo que no podría dar error. Elige entonces curarse en salud.

 this

En algunos momentos puede resultar útil tener una referencia a la instancia actual, aquella que se está ejecutando. Por ejemplo:

public class Peano {
  private int i = 0;
  Peano sucesor() {
    i++;
    return this;
  }
  Peano escribir() {

    System.out.println(i);
  }
  public static void main(String[] args) {
    Peano x = new Peano();
    x.sucesor().sucesor().escribir();
  }
}

En este caso el método sucesor no sólo incrementa la propiedad privada i, sino que se devuelve a sí mismo, lo que permite llamarlo varias veces en la misma sentencia. Por otro lado, this también se puede utilizar como método, o más bien como constructor. En ocasiones puede ser muy cómodo, cuando tenemos diversos constructores con diversos parámetros, permitir que se llamen entre ellos. Por ejemplo, en nuestro ejemplo del rectángulo:

/** Calcula el area de un rectangulo
 */
public class Rectangulo {
  private float x1,y1,x2,y2;
  public Rectangulo(float ex1, float ey1, float ex2, float ey2) {
    x1 = ex1;
    x2 = ex2;
    y1 = ey1;
    y2 = ey2;
  }
  public Rectangulo() {
    this(0, 0, 1, 1);
  }
  public float calcularArea() {
    return (x2?x1) * (y2?y1);
  }
  public static void main(String[] args) {
    Rectangulo prueba1 = new Rectangulo(1,4,7,6);
    Rectangulo prueba2 = new Rectangulo();
    System.out.println(prueba1.calcularArea());
    System.out.println(prueba2.calcularArea());
  }
}

Sólo hemos modificado desde la última versión el constructor sin argumentos. Ahora, en lugar de modificar directamente los valores de las variables, llama al constructor que admite cuatro parámetros utilizando this.

 super

En muchos casos, al sobreescribir un método, puede que necesitemos el código del método de la clase padre. En ese caso, en lugar de reescribirlo todo entero, podemos llamar a ese otro método de la clase inmediatamente superior por medio de la variable super:

class Mamifero {
  String especie, color;
  public void mover() {
    System.out.println("El mamífero se mueve");
  }
}

class Gato extends Mamifero {
  int numero_patas;
  public void mover() {
    super.mover();
    System.out.println("El gato es el que se mueve");
  }
}

public class UsarSuper {
  public static void main(String[] args) {
    Gato bisho = new Gato();
    bisho.mover();
  }
}

Ahora veremos que, al llamar al método mover() de Gato, éste a su vez llama al de Mamifero..