Binding dinamico

[svamp92]

Ciao a tutti,

in questi giorni mi trovo ad affrontare dei problemi dovuti al binding dinamico di Java.

Dato il codice che riporto sotto dovrei riuscire a capire cosa il programma stamperebbe nel caso in cui eseguissi nel main le istruzioni che riporto sotto il codice. Le soluzioni sarebbero:

Point1D.distance
1.0
Point2D.distance
1.4142135623730951
Point1D.distance
0.0
Point2D.distance
Exception in thread "main" java.lang.ClassCastException: Point1D cannot be cast to Point2D
Se poi l’esecuzione proseguisse:
Point1D.distance
1.0
Point2D.distance
1.4142135623730951


Potreste spiegarmi per bene i passaggi di cosa fa il compilatore a run-time e in particolare perché viene generata quell'eccezione alla quarta stampa e non all'ultima?

Grazie mille.

public abstract class Point {                                                 
 
 public abstract double distance (Point p);

}

                    
public class Point1D extends Point {
  
private double c1;
 
 public Point1D (double c1) {
     this.c1 = c1;
  }

  public double getC1() {
     return c1;
  }

 public double distance (Point p) {
      return Math.abs(((Point1D) p).getC1()-c1);
  }}
                    

public class Point2D extends Point1D {
   private double c2;

  public Point2D (double c1, double c2) {
      super(c1);
    this.c2 = c2;
   }
 
public double getC2() {
      return c2;
}
                       
public double distance (Point p) {
      return Math.sqrt(Math.pow(((Point2D) p).getC1()-this.getC1(), 2) +
     Math.pow(((Point2D) p).getC2()-this.getC2(), 2));
    }
    
public double distance (Point2D p) {
      return Math.sqrt(Math.pow(p.getC1()-this.getC1(), 2) +        
                 Math.pow(p.getC2()-this.getC2(), 2));                     
}}
 

Point p1 = new Point1D(0.0);
Point p2 = new Point1D(1.0);
Point p3 = new Point2D(0.0, 1.0);
Point p4 = new Point2D(1.0, 0.0);
double x;
x = p1.distance(p2);
System.out.println(x);
x = p3.distance(p4);
System.out.println(x);
x = p1.distance(p3);
System.out.println(x);
x = p3.distance(p1);
System.out.println(x);
p1=p3;
x = p2.distance(p1);
System.out.println(x);
x = p4.distance(p1);
System.out.println(x);

[andbin]

Innanzitutto c'è un concetto teorico che è sbagliato, ovvero la gerarchia che hai fatto. Potrebbe ad esempio venirti in mente di fare una ulteriore classe es. Point3D che estende Point2D. Sbagliato concettualmente! Un Gatto è un caso particolare di Animale, una Automobile è un caso particolare di Veicolo. Ma un punto 3D NON è un caso particolare di punto 2D. Idem tra 1D e 2D.
Dovunque è lecito assegnare o passare un Point1D, puoi tecnicamente passare un Point2D. Ma non avrebbe senso.

Infatti non ha senso es.:

double d = unPoint1D.distance(unPoint2D);

Stop, fine della questione.


E per tornare alla questione del binding dinamico, basta tenere a mente due cose:
- il compilatore sceglie solo la "firma" del metodo (eventualmente tra quelle in overload) basandosi solo sul tipo "statico" del reference. Ad esempio in base al tipo della variabile su cui si sta invocando il metodo.
- a runtime la implementazione del metodo che viene eseguito è quella dell'oggetto realmente istanziato.

Se vuoi approfondire questi aspetti, innanzitutto scegli un design più appropriato.