## El Cuerpo del Método

En el siguiente ejemplo, el cuerpo de método para los métodos estaVacio() y poner() están en negrita:

    class Stack {
        static final int PILA_VACIA = -1;
        Object[] elementosPila;
        int elementoSuperior = PILA_VACIA;
        . . .
        boolean estaVacio() {
            if (elementoSuperior == PILA_VACIA)
                return true;
            else
                return false;
        }
        Object poner() {
            if (elementoSuperior == PILA_VACIA)
                return null;
            else {
                return elementosPila[elementoSuperior--];
            }
        }
    }

Junto a los elementos normales del lenguaje Java, se puede utilizar this en el cuerpo del método para referirse a los miembros del objeto actual. El objeto actual es el objeto del que uno de cuyos miembros está siendo llamado. También se puede utilizar super para referirse a los miembros de la superclase que el objeto actual haya ocultado mediante la sobreescritura. Un cuerpo de método también puede contener declaraciones de variables que son locales de ese método.

### this

> Normalmente, dentro del cuerpo de un método de un objeto se puede referir directamente a las variables miembros del objeto. Sin embargo, algunas veces no se querrá tener ambiguedad sobre el nombre de la variable miembro y uno de los argumentos del método que tengan el mismo nombre.

> Por ejemplo, el siguiente constructor de la clase HSBColor inicializa alguna variable miembro de un objeto de acuerdo a los argumentos pasados al constructor. Cada argumento del constructor tiene el mismo nombre que la variable del objeto cuyo valor contiene el argumento.

>     class HSBColor {
>         int hue, saturacion, brillo;
>         HSBColor (int luminosidad, int saturacion, int brillo) {
>             this.luminosidad = luminosidad;
>             this.saturacion = saturacion;
>             this.brillo = brillo;
>         }
>     }

Se debe utilizar this en este constructor para evitar la embiguedad entre el argumento luminosidad y la variable miembro luminosidad (y así con el resto de los argumentos). Escribir luminosidad = luminosidad; no tendría sentido. Los nombres de argumentos tienen mayor precedencia y ocultan a los nombres de las variables miembro con el mismo nombre. Para referirise a la variable miembro se debe hacer explicitamente a través del objeto actual--this.

También se puede utilizar this para llamar a uno de los métodos del objeto actual. Esto sólo es necesario si existe alguna ambigüedad con el nombre del método y se utiliza para intentar hacer el código más claro.

### super

> Si el método oculta una de las variables miembro de la superclase, se puede referir a la variable oculta utilizando super. De igual forma, si el método sobreescribe uno de los métodos de la superclase, se puede llamar al método sobreescrito a través de super.

> Consideremos esta clase:

>     class MiClase {
>         boolean unaVariable;
>         void unMetodo() {
>             unaVariable = true;
>         }
>     }

> y una subclase que oculta unaVariable y sobreescribe unMetodo():

>     class OtraClase extends MiClase {
>         boolean unaVariable;
>         void unMetodo() {
>             unaVariable = false;
>             super.unMetodo();
>             System.out.println(unaVariable);
>             System.out.println(super.unaVariable);
>         }
>     }

> Primero unMetodo() selecciona unaVariable (una declarada en OtraClase que oculta a la declarada en MiClase) a false. Luego unMetodo() llama a su método sobreescrito con esta sentencia:

>     super.unMetodo();

> Esto selecciona la versión oculta de unaVariable (la declarada en MiClase) a true. Luego unMetodo muestra las dos versiones de unaVariable con diferentes valores:

>     false
>     true

### Variables Locales

> Dentro del cuerpo de un método se puede declarar más variables para usarlas dentro del método. Estas variables son variables locales y viven sólo mientras el control permanezca dentro del método. Este método declara un variable local i y la utiliza para operar sobre los elementos del array.

>     Object encontrarObjetoEnArray(Object o, Object[] arrayDeObjetos) {
>         int i;      //  variable local
>         for (i = 0; i < arrayDeObjetos.length; i++) {
>             if (arrayDeObjetos[i] == o)
>                 return o;
>         }
>         return null;
>     }

> Después de que este método retorne, i ya no existirá más.

Ozito