Se desea definir una clase Punto que implementa las siguientes operaciones:

Punto p= new Punto(3, 4);
System.out.println(p);     // (3,4)

p.moverEn(1, 2);
System.out.println(p);     // (11,12)

Ejercicio:

• Copie la clase Punto.java a su directorio y compílelo.

• Copie el archivo Hello.java a PruPunto.java. Edite PruPunto.java y cambie el nombre de la clase Hello por PruPunto.

• En el procedimiento main:
  • Cree un punto con new Punto(1,2) y asígnelo a una variable p de tipo Punto. Muéstrelo con System.out.println(p).

  • Desplácelo con p.moverEn(5,10) y vuelva a mostrarlo.

  • Cree otro punto q en (100,100), muévalo en 2,2 y muestre p y q.

• Compile y ejecute.

Para definir una clase se usa:

public class Nombre {
  // Definiciones
  Constructores
  Variables de instancia de objetos
  Métodos
  Variables estáticas (compartidas)
  Métodos estáticos
}

La clase debe estar definida en un archivo Punto.java con contenido:

public class Punto {
  int x, y; // Variables de instancia

  public Punto(int x, int y) { // El constructor
    this.x= x; this.y= y;
  }
  public void moverEn(int dx, int dy) { // Un método
    this.x+= dx; this.y+= dy;
  }
  public String toString() { // Otro método
    return "("+this.x+","+this.y+")";
  }
}

• x e y son las variables de instancia que llevará cada punto creado.

• moverEn y toString son los métodos que se puede invocar sobre cada punto.

• El orden en que se hagan las definiciones de variables de instancia y métodos es irrelevante.

• Punto no es un método. Es un constructor y se invoca automáticamente cada vez que se crea un objeto con new. Se distingue de un método porque lleva el mismo nombre de la clase y no tiene tipo de retorno.

• Al interior de la definición de un método, la variable this contiene una referencia del objeto con que se invocó ese método.

• Un método es equivalente a lo que es un procedimiento (función o subrutina) en un lenguaje de programación tradicional.

• La diferencia es que un método tiene al menos un argumento: el objeto de la invocación.

• En la definición del método, el objeto de la invocación es referenciado por el identificador (reservado) this.

• Un método puede accesar variables de instancia e invocar métodos.

• Para accesar la variable de instancia v de un objeto o se usa la notación:

       o.v
  

• Para modificar el valor de una variable de instancia:

       o.v = expresión;
  

• Se puede accesar y modificar una variable de instancia del objeto de la invocación (this):

       this.x= this.x + 1;
  

Ejercicio: definir el método moverA.

• Edite el programa Punto.java.

• Agregue a la clase Punto el método moverA, tal que:

  Punto p= new Punto(10,10);
  p.moverA(5,5);
  System.out.println(p); // Debe mostrar: (5,5)
  

  Fíjese en la definición del método moverEn(...).

• Compile nuevamente Punto y pruébelo con:java PruMoverA

Ejemplo: Se desea agregar un método a la clase Punto que calcule la distancia entre este punto y un segundo punto recibido como argumento:

Punto p= new Punto(100, 100);
Punto q= new Punto(103, 104);

System.out.println( p.distanciaA(q) ); // 5
System.out.println( q.distanciaA(p) ); // 5
System.out.println( p.distanciaA(p) ); // ?

Solución:

public class Punto {
  ...
  public double distanciaA(Punto punto) {
    int dx= punto.x - this.x;
    int dy= punto.y - this.y;
    return Math.sqrt(dx*dx+dy*dy);
  }
}

Un método también puede invocar otros métodos y retornar objetos.

Ejemplo: un método que recibe 2 puntos y entrega aquel que esté más lejos de este punto.

public class Punto {
  ...
  public Punto masLejano(Punto p, Punto q) {
    if (this.distanciaA(p) >= this.distanciaA(q))
      return p;
    else
      return q;
  }
}

Ejemplo de uso:

Punto p= new Punto(100, 100);
Punto r= p.masLejano(new Punto(101,101), new Punto(1,1));
System.out.println(r); // (1,1)

En la definición del método masLejano este objeto es referenciado por otro identificador. ¿Cuál?

Ejercicio: agregue el método suma a la clase Punto. El método debe sumar este punto con un segundo punto recibido como argumento y entregar el resultado en un nuevo punto.

Punto p= new Punto(10, 100);
Punto q= new Punto(20, 100);

Punto r= p.suma(q);

System.out.println(r); // (30,200)

// Cuidado! los puntos p y q no deben ser alterados
System.out.println(p); // (10,100)
System.out.println(q); // (20,100)

Resuelva este problema de la siguiente forma:

public class Punto {
  ...
  // El método recibe un punto como argumento y
  // entrega como resultado un nuevo punto:
  public Punto suma(Punto p) {
    Obtenga las coordenadas de este punto con
         this.x y this.y
    Obtenga las coordenadas de p con
         p.x y p.y
    Sume coordenada a coordenada estos valores
    y construya un nuevo punto con el resultado
    (usando new)
    Retorne el resultado al invocador mediante
    return el nuevo punto;
  }
}

• Recompile la clase Punto.java.

• Pruebe su programa ejecutando:

           java PruSuma
  

Las variables de instancia se pueden accesar sin pasar por this (si no hay ambiguedad con variables locales). La clase Punto se puede reescribir:

public class Punto {
  int x, y; // Variables de instancia
  public Punto(int x, int y) { // El constructor
    this.x= x; this.y= y; // no se puede suprimir this
  }
  public void moverEn(int dx, int dy) { // Un método
    // this.x += dx; this.y += dy;
    x += dx; y += dy;
  }
  public String toString() { // Otro método
    // return "("+ this.x +","+ this.y +")";
    return "("+ x +","+ y +")";
  }
  ...
}

De la misma forma, se pueden invocar otros métodos del mismo objeto sin pasar por this. El método masLejano se puede reescribir:

public class Punto {
  ...
  public Punto masLejano(Punto p, Punto q) {
    // if (this.distanciaA(p) >= this.distanciaA(q))
    if (distanciaA(p) >= distanciaA(q))
      return p;
    else
      return q;
  }
}

• Un método se identifica por su nombre, el número de argumentos que recibe y el tipo de sus argumentos. Esto constituye la firma del método (signature).

• En una clase se pueden definir varios métodos con el mismo nombre, siempre y cuando difieran en el tipo de sus argumentos.

• Por ejemplo, Punto puede tener dos métodos moverA:

    public void moverA(Punto dest) { ... }
    public void moverA(int x, int y) { ... }
  

• La firma del primer moverA es moverA(Punto) y la del segundo es moverA(int,int).

Al invocar un método, el compilador busca en la clase el método que corresponda a los argumentos de la invocación.

  Punto p= new Punto(10,10);
  Punto q= new Punto(100,100);

  p.moverA(q);     // busca moverA(Punto)
  p.moverA(0,0);   // busca moverA(int,int)
  p.moverA("la esquina"); // Error en compilación