Métodos

Los métodos son la siguiente parte importante de todo esto, representan las acciones que nuestro objeto puede hacer:

Es el nombre de las funciones en Java. Su sintaxis es:

public Tipo nombreDeMétodo(){
     sentencias;
     ...
     return Atributo
}

---

Métodos Especiales

Cuando se coloca un atributo en Java en privado para poder acceder a el se hacen métodos o funciones que dan permisos de Leer y Escribir (o llamadas GET y SET).

Métodos GET

Este tipo de funciones lo que devuelve es el atributo deseado, para que lo puedan ver desde fuera de la clase pero no puedan modificarlo.

public Tipo getAtributo(){
    return Atributo;
}

Ejemplo:

//Ejemplo 1
public String getNombre(){
    return Nombre;
}

//Ejemplo 2 (Usando Constructores)
public Tipo getAtributo(){
    return new Tipo(Atributo);
}

//Ejemplo 3 (Usando Constructores de Copia)
public vertice getA(){
    return new vertice(a);
}

Métodos SET

Este tipo de funciones lo que hace es darle valor a un atributo deseado, para que lo puedan ver desde fuera de la clase pero no puedan modificarlo.

Nota: Al referirnos al this.Atributo lo que estamos haciendo es referirnos al atributo de la clase, y al solo poner Atributo dentro del método nos referimos al atributo que acabamos de crear como parámetro del método.

public void setAtributo(){
     this.Atributo = Atributo;
}

Ejemplo:

//Ejemplo 1
public void getNombre(String Nombre){
   this.Nombre = Nombre;
}

---

Métodos de Object

Todos los objetos en Java son hijos de la clase Object, por lo que existen unos métodos bastante comunes que nosotros podemos sobre escribir y que nos muy útiles.

Método toString()

Cuando tu colocas el nombre de tu objeto donde venia ir un string se llama de forma automática este método. Generalmente se espera que regrese un string.

Método equals()

Es muy común que se llame para saber si dos objetos con lo «mismo» tu puedes modificarlo según lo que para ti se considere que tu objeto sea «igual» al otro.

Método finalize()

Se llama al colector de basura, nos permite guardar el estado o datos que creemos que son necesarios conservar antes de «borrar» un objeto.

---

Constructor

Es un método que evita tener que llenar los valores de cada objeto. Suele ser el primer método que se encuentra en cada clase, justo después de la declaración de atributos.

Aquí te coloco sus características mas comunes:

• Tiene el mismo nombre que la clase
• Generalmente es público
• Su objetivo (su motivo en la vida) es inicializar el estado de los atributos de una clase
• Se puede sobrecargar

Forma Básica

public NombreClase(Tipo Algo1, Tipo Algo2){
   this.Algo1 = Algo1;
   this.Algo2 = Algo2;
}

Constructores de Copia

Este tipo de constructores se usan cuando se crean objetos de objetos, decir, y valga la redundancia, copia o clona un objeto que ya existe.

Este tipo de constructores permiten crear objetos que serán independientes de sus paramentos una vez creados, pues de otra manera si se modificarán los atributos que usa un constructor para crear un objeto, los atributos del objeto en sí serán cambiados.

Usado cuando se crean objetos que reciben como parámetros de creación otros objetos.

public NombreClase(NombreClase ObjetoACopiar){
Algo1 = ObjetoACopiar.Algo1();
Algo2 = ObjetoACopiar.Algo2();
...
}

Ejemplo:

public Triangulo(Punto 1, Punto 2, Punto 3){
this.1 = new Punto(1);
this.2 = new Punto(2);
this.2 = new Punto(3);
}

Entonces no se llaman ya a los métodos SET and GET sino solo:

clase Nombre = new clase(Algo1,Algo2...)

Tipo NO tiene porque ser sólo int o strings sino que puede recibir objetos de tipos que hemos creado como autos o figuras.

---

Destructor

Java no tiene en si un destructor, pero si que tiene algo muy parecido, te mostrare:

public void Destruir(){
Algo1 = null;
Algo2 = null;
System.gc();
}

---

Sobrecarga de Métodos

Finalmente algo muy importante de lo que hablar es de la sobrecarga que permite que existan en una clase varios métodos que se llamen diferente y permite una mayor versatilidad.

Si principal ventaja es que permite reutilizar muchísimo código.

Hay varias características:

• No importan si unos son public o private
• Igual tipo de datos devuelto
• Igual nombre del método
• Distintos parámetros

Por ejemplo, veamos la clase de Ejemplo:

package LogicaDelSistema;

public class Persona {

    // ====== Atributos =====
    private int edad;
    private String nombre;
    private boolean sexo;

    // === Constructor ======
    public Persona(){
        this(0,"",false);

    }
    // === Constructor SobreCarga ===
    public Persona(int edad, String nombre, boolean sexo){
        this.edad = edad;
        this.nombre = nombre;
        this.sexo = sexo;
    }
    // === Constructor Copia ===
    public void setPersona(Persona PersonaOriginal){
        this.edad = PersonaOriginal.edad;
        this.nombre = PersonaOriginal.nombre;
        this.sexo = PersonaOriginal.sexo;
    }
    // === Constructor SET ===
    public void setPersona(int edad, String nombre, boolean sexo){
        this.edad = edad;
        this.nombre = nombre;
        this.sexo = sexo;
    }

    public String toString(){
        String mensaje;
        if(sexo){mensaje= "Hombre";}
        else{mensaje = "Mujer";}
        return "Edad:"+edad+"\n"+"nombre:"+nombre+"\n"+"sexo:"+mensaje;
    }

    public void Comer(){
        System.out.print("Comiendo ");
    }

    public void Comer(String comida){
        Comer();
        System.out.print(comida);
    }

    public void Comer(String comida, String amigo){
        Comer(comida);
        System.out.print(" con "+amigo);
    }

}

---

Sobrecarga de Operadores

Naaaaaahh…. Java no la tiene XD.

Pero aun así es un tema muy interesante, así que solo, SOLO con este tema te contaré lo que hace C++.

Así que olvida por un rato que estamos en Java y veamos como lo hace la competencia:

Por ejemplo, veamos la clase de Ejemplo:

tipo nombre_clase::operator + (lista de parámetros);

Podemos ver distinguir entre 2 Operaciones:

Los operadores binarios se declaran con un solo parámetro, ya que el primer parámetro es pasado por el programa como this, es decir, un puntero al mismo objeto.

// Binario
Objeto Objeto::operator + (Objeto &B);
Objeto A, B, C;
C = A + B;               // C = A.operator+(&B);

Los operadores unarios se declaran sin paramétros, ya que el único parámetro es pasado por el programa como this.

// Unario
Objeto Objeto::operator ++ (int Basura);
Objeto A, C;
C = A++;                 // C = A; A = A + 1;
C = A++;                 // C = A.operator++(int Basura);

This vs *This

class Foo {
    public:
        Foo(){
            this->value = 0;
        }

        Foo tenCopia(){
            return *this;
        }

        Foo& copiaComoReferencia(){
            return *this;
        }

        Foo* tenPuntero(){
            return this;
        }

        void aumenta(){
            this->value++;
        }

        void imprime(){
            std::cout<< this->value << "\n";
        }
}

Así podemos ver que:

int main(){
    Foo foo;
    foo.aumenta();
    foo.imprime();

    foo.tenCopia().aumenta();
    foo.imprime();

    foo.copiaComoReferencia().aumenta();
    foo.imprime();

    foo.tenPuntero()->aumenta();
    foo.imprime();

    return 0;
}

Así tenemos este resultado:

1
1
2
3