THIS

La palabra clave this es una referencia al propio objeto. En versión larga. Cuando definimos una clase ( idea abstracta que despues se concretará con cada instancia) a veces nos interesa hacer referencia a la própia instancia. Como que en el momento de crear la clase no sabemos que nombre le daremos a la instancia usamos el genérico “this”. En el lenguaje cotidiano sería un “yo”. De esta manera podemos hacer referencia a la instancia misma sin saber su nombre (yo en sustitución de José Palotes). ahi va el ejemplo simple:

// Hoja.java
// Ejemplo de la palabra this.
public class Hoja{
int i=0;
Hoja incrementar(){
i++;
return this;
}
void print(){
System.out.println("i = "+i);
}
public static void main(String[] args){
Hoja x = new Hoja();
x.incrementar().incrementar().incrementar().print();
}
}

Y el resultado será … que imprime “i = 3”. Comento paso por paso para tambien refrescar.

El archivo se llama Hoja.java igual que la única clase pública del archivo “public class Hoja()
Para definir un método (una funcion) hay que decir si es publico o no, estatico o no y el tipo de cosa que va a devolver. El nombre del método y los parametros que recive entre parentesis.
public static void metodo(parametro)
Por lo que el metodo Hoja incrementar() no es público, no es estatico y lo que devuelve es un objeto del tipo Hoja. Se llama “incrementar” y no revive parámetros poque no hay nada dentro de los corchetes ()

El método “incrementar” devuelve this por lo que.. se devuelve a sí mismo por lo que al final de su ejecución tenemos otra vez un objeto hoja de el que se puede llamar a el método incrementar.

Tambien se puede usar la palabra this para distinguir entre constructores sobrecargados. Por ejemplo. Quieres escribir un método sobrecargado pero parte del método es común a todos los inicializadores. Como que This hace referencia al objeto (yo) puedes usarlo para este fin.

// Flor.java
// invocar a constructores sobrecargados con this
public class Flor{
int numeroDePetalos = 0;
String s = new String("null");
void P(String cadena){
System.out.println(cadena);
}
Flor(int petalos){
numeroDePetalos = petalos;
P("Creando una flor de " + petalos + " petalos.");
}
Flor(String s){
P("Creando una flor de w/ parametro cadena.");
s = s;
}
Flor(String cadena, int petalos){
this(petalos);
// this(s) !! no se puede invocar dos veces
this.s = cadena;
P("cadena y entero=======>");
}
Flor(){
this("hola",23);
P("constructor por defecto, sin parametros");
}
void print(){
P("funcion, aqui no se puede usar this(12) \n sólo en los contructores");
}  
public static void main(String agrs[]){
Flor f = new Flor();
f.print();
}
}

Apreciaras que el constructor de la cadena está ahi pero que esta vez no lo hemos utilizado.