ereditarietà classi

[LuciaAme]

Ciao Ragazzi sono nuova di questo forum, ho un problema con il richiamo di costruttori all'interno della classe stessa. Vi spiego meglio.
Devo fare un esercizio che comprende le seguenti classi:

public class  Punto  {

  // CAMPI
  private int x; // ascissa del punto
  private int y; // ordinata del punto

 // COSTRUTTORI
    public Punto(int x, int y){
		this.x = x;
		this.y = y;
    }

  //METODI VARI
  .......
}

poi ho la classe Rettangolo2:

public class  Rettangolo2  {
  // CAMPI
    private Punto p1; // punto P1 (vertice in basso a sinistra)
    private Punto p2; // punto P2 (vertice in alto a destra)
    private int base;  // misura della base
    private int altezza;    // misura dell'altezza

 // COSTRUTTORI
    public Rettangolo2(Punto puntoA, Punto puntoB){
    	this.p1 = puntoA.minXminY(puntoB);
    	this.p2 = puntoB.maxXmaxY(puntoA);
    	
    }
    public Rettangolo2(int xA, int yA, int xB,  int yB){
		this(new Punto(xA,yA),new Punto(xB,yB));        
    }

 // METODI 
  public String toString() {
	  String s = "((" + p1.getX() + "," + p1.getY() + "), " + "(" + p2.getX() + "," + p2.getY() + ")";   
      return s;
  }

public int getBase() {
	this.base = (p2.getX()-p1.getX());
    return this.base;
  }

public int getAltezza() {
	this.altezza = (p2.getY()-p1.getY());
    return this.altezza;
}

/**
   * Restituisce i vertici del rettangolo ordinati in senso  orario   a partire da P1.
   * @return Restituisce un array  contenente i vertici del rettangolo che esegue 
   * il metodo, ordinati in senso  orario   a partire da P1.
   */
    public Punto[] getVertici(){
    	Punto[] array = new Punto[4];
    	Punto p = new Punto(0,0);
    	
    	if(p1.minXminY(p2) != null)
    		array[0] = new Punto(p1.getX(),p2.getY());
    	if(p1.minXmaxY(p2) != null)
    		array[1] = new Punto(p1.getX(),p2.getY());
    	if(p1.maxXmaxY(p2) != null)
    		array[2] = new Punto(p1.getX(),p2.getY());
    	if(p1.maxXminY(p2) != null)
    		array[3] = new Punto(p1.getX(),p2.getY());
	return array;
    }
    // METODI VARI
}

e poi la terza classe Quadrato2

public class  Quadrato2 extends Rettangolo2 {

  // CAMPI
    private int lato;  // misura della base
    
 // COSTRUTTORI
/*** Costruisce il quadrato in cui il vartice in basso a sinistra è <code>(x,y)</code> e 
      la misura del lato è <code>lato</code> (si assume <code>lato </code> > 0).
 */
    public Quadrato2(int x,  int y, int lato){
	// chiamare correttamente il costruttore della superclasse (Rettangolo)
    	super(x,y,,);
    	this.lato = lato;
    }
    /*** Costruisce il quadrato in cui il vartice in basso a sinistra è <code>p</code> e 
         la misura del lato è <code>lato</code> (si assume <code>lato </code> > 0).
 */
    public Quadrato2(Punto p, int lato){
	// chiamare correttamente il costruttore precedente
    	this(1,1,lato);
    }
 // METODI
}

[satifal]

...quindi?!

[LuciaAme]

Il file di input è il seguente:
1 1 2 2
2 10 0 0
5 8 15 6
7 1 2 10
-4 10 4 -2
5 -10 -10 -20

ed il mio file di Test:

public static void main(String[] args) throws Exception{
	Scanner in = new Scanner(System.in);
	FileReader fr = new FileReader("Punti.txt");
	BufferedReader br = new BufferedReader(fr);
	String s = br.readLine();
		
	ArrayList<Rettangolo2> lista = new ArrayList<Rettangolo2>();
	Punto[] punti = new Punto[4];
	
	while(s != null){
		Rettangolo2 r = null;
		String[] array = s.split(" ");
		
		String a = array[0];
		String b = array[1];
		String a1 = array[2];
		String b1 = array[3];
	
		int x = Integer.parseInt(a);
		int y = Integer.parseInt(b);
		int x1 = Integer.parseInt(a1);
		int y1 = Integer.parseInt(b1);
		r = new Rettangolo2(x,y,x1,y1);
		punti = r.getVertici();
		
		lista.add(r);
		
		s = br.readLine();
	}

	for(Rettangolo2 ret : lista){
		System.out.println(ret + " -- Vertici: " + punti + 
				" -- Perimetro: " + ret.getPerimetro() + 
				" -- Area: " + ret.getArea());
	}	
}

Prima di tutto c'è questo problema che non riesco a stampare i punti e non so se il metodo r.getVertici() sia giusto...mi potete aiutare??
Ho la soluzione e deve uscire in questo modo:
((1,1),(2,2)) -- Vertici: (1,1) (1,2) (2,2) (2,1) -- Perimetro: 4 -- Area: 1
((0,0),(2,10)) -- Vertici: (0,0) (0,10) (2,10) (2,0) -- Perimetro: 24 -- Area: 20
((5,6),(15,8)) -- Vertici: (5,6) (5,8) (15,8) (15,6) -- Perimetro: 24 -- Area: 20
((2,1),(7,10)) -- Vertici: (2,1) (2,10) (7,10) (7,1) -- Perimetro: 28 -- Area: 45
((-4,-2),(4,10)) -- Vertici: (-4,-2) (-4,10) (4,10) (4,-2) -- Perimetro: 40 -- Area: 96
((-10,-20),(5,-10)) -- Vertici: (-10,-20) (-10,-10) (5,-10) (5,-20) -- Perimetro: 50 -- Area: 150

Poi l'altro mio problema è che non riesco a costruire i costruttori della classe Quadrato2 appunto usando l'erediatarietà

Grazi mille

[satifal]

    ...
    public Quadrato2(int x,  int y, int lato) {
    	super(x, y, x + lato, y + lato);
    	this.lato = lato;
    }
    ...

[LuciaAme]

grazie per la risp

cmq non dovrebbe essere lato-x e lato-y?

se tipo ho in input la seguente linea
-1 -1 7
per essere un quadrato deve avere i seguenti punti (-1,-1),(6,6)...

e per il secondo costruttore??

[satifal]

Originariamente inviato da LuciaAme
grazie per la risp

cmq non dovrebbe essere lato-x e lato-y?

se tipo ho in input la seguente linea
-1 -1 7
per essere un quadrato deve avere i seguenti punti (-1,-1),(6,6)...

e per il secondo costruttore??

Qui leggo:

// COSTRUTTORI
/*** Costruisce il quadrato in cui il vartice in basso a sinistra è <code>(x,y)</code> e
la misura del lato è <code>lato</code> (si assume <code>lato </code> > 0).
*/

quindi x e y indicano le coordinate del vertica in basso a sinistra da cui per ottenere il vertice in alto a destra occorre sommare il lato alle due coordinate.
Infatti, nel tuo esempio (-1, -1, 7) si ha che x1 = -1, y1 = -1, x2 = -1 + 7 = 6, y2 = -1 + 7 = 6.

Per il secondo costruttore il ragionamento è esattamente equivalente, solo che invece delle coordinate devi passare direttamente due oggetti di tipo Punto.

[LuciaAme]

ok ok ho fatto così:

// COSTRUTTORI
/*** Costruisce il quadrato in cui il vartice in basso a sinistra è <code>(x,y)</code> e 
      la misura del lato è <code>lato</code> (si assume <code>lato </code> > 0).
 */

    public Quadrato2(int x,  int y, int lato){
	// chiamare correttamente il costruttore della superclasse (Rettangolo)
    	super(x,y,lato+x,lato+y);
    	this.lato = lato;
    }
    /*** Costruisce il quadrato in cui il vartice in basso a sinistra è <code>p</code> e 
         la misura del lato è <code>lato</code> (si assume <code>lato </code> > 0).
 */

    public Quadrato2(Punto p, int lato){
	// chiamare correttamente il costruttore precedente
    	this(p.getX(),p.getY(),lato);
    }

poi per quanto riguarda la stampa dei vertici come devo fare??

[LuciaAme]

oltre al problema del mess di prima...
devo creare 2 metodi nella classe Rettangolo:
- public Rettangolo copertura(Rettangolo r)

Restituisce la copertura del rettangolo che esegue il metodo e
del rettangolo r passato come argomento.


- public Rettangolo intersezione(Rettangolo r)

Restituisce il rettangolo intersezione fra il rettangolo che esegue il metodo
e il rettangolo r passato come argomento oppure null se l'intersezione non e' definita.

Usare i metodi minXminY, ... della classe Punto

Ho provato a fare il primo ma mi da punti diversi:

public  Rettangolo2 copertura(Rettangolo2 r){
  	Punto p = p1.minXminY(r.p2);
    	Punto p2 = p1.maxXmaxY(r.p2);
    	return new Rettangolo2(p,p2);
}

se tipo ho il seguente input:
0 0 10 4 2 -4 6 20
la copertura è questa:
((0,-4),(10,20))

cioè devo prendere il punto più piccolo e quello più grande...dove sbaglio?

[LuciaAme]

credo che il metodo sia giusto però non riesco a capire come si stampa correttamente

public Punto[] getVertici(){
    	Punto[] array = new Punto[4];
   		array[0] = p1.minXminY(p2);
   		array[1] = p1.minXmaxY(p2);
   		array[2] = p1.maxXmaxY(p2);
  		array[3] = p1.maxXminY(p2);
	return array;
    }

adesso nel file di test che è il seguente:

FileReader fr = new FileReader("Punti.txt");
BufferedReader br = new BufferedReader(fr);
String s = br.readLine();
	
ArrayList<Rettangolo2> lista = new ArrayList<Rettangolo2>();
Punto[] punti = new Punto[4];
		
while(s != null){
	Rettangolo2 r = null;
	String[] array = s.split(" ");
			
	String a = array[0];
	String b = array[1];
	String a1 = array[2];
	String b1 = array[3];
			
	int x = Integer.parseInt(a);
	int y = Integer.parseInt(b);
	int x1 = Integer.parseInt(a1);
	int y1 = Integer.parseInt(b1);

	r = new Rettangolo2(x,y,x1,y1);
	punti = r.getVertici();
			
	lista.add(r);
			
	s = br.readLine();
        }
		
	for(Rettangolo2 ret : lista){
		System.out.println(ret + " -- Vertici: " + punti + 
			" -- Perimetro: " + ret.getPerimetro() + 
			" -- Area: " + ret.getArea());
	}

non me li stampa ovviamente...ma li devo mettere in una lista o qualcosa del genere??
la stampa che deve uscire è riportata in qualche mess di prima

[VincenzoTheBest]

Originariamente inviato da LuciaAme
non me li stampa ovviamente...ma li devo mettere in una lista o qualcosa del genere??
la stampa che deve uscire è riportata in qualche mess di prima

Non basta fare:

System.out.println(" -- Vertici: " + punti)

in questo modo stampi il riferimento. Per stampare l'intero array di punti devi iterarlo e stampare ogni singolo Punto.