Programma Java per la gestione di un aerodromo

Esercizio 6

In un'aerodromo si vuol mantenere informazioni sugli aeromobili.
Di ogni aeromobile si vuole sapere la sigla (string) che lo identifica.
Gli alianti sono aeromobili caratterizzati da un numero (int) che ne descrive l'efficienza aereodinamica. Degli aerei a motore si vuole sapere la potenza in CV del motopropulsore (double).

Aeromobili dello stesso tipo devono essere confrontabili fra loro in modo da poter stabilire quale sia quello con prestazioni migliori.
Gli alianti si confrontano in base all'efficienza; gli aerei a motore in base alla potenza in CV.

Scrivi un'interfaccia pubblica CMP contenente un metodo boolean superiore (CMP x) per verificare se un aeromibile (this) è superione ad un altro x come prestazioni.
Il metodo deve sempre restituire false se x=null o se gli oggetti coinvolti nel confronto non sono dello stesso tipo.

Scrivi tre classi pubbliche: aeromobile (A) aliante (AL) ed aereomotore (AM) ciascuna con un metodo get pubblico per accedere all'attributo specifico della classe.
Ogni classe deve fornire anche:un costruttore, i metodi equals e toString.
Il codice scritto deve rispettare i seguenti vincoli:
— La classe aeromobile (A) deve implementare l'interfaccia CMP.
— Aliante (AL) ed aereomotore (AM) devono estendere aeromobile (A).
— Deve esserci almeno una classe astratta.

Dal testo del problema si realizza che nell'aerodromo ci sono degli aeromobili che hanno tutti una sigla diversa. Certamente, il parametro sigla costituisce un attributo per ogni singolo aeromobile ( oggetto di classe A).
Gli aeromobili sono poi suddivisi in due categorie: gli alianti ( oggetti di classe AL) e gli aerei a motore (oggetti di classe AM). Queste due ultime classi possono essere derivate dalla classe aeromobile A perchè ne costituiscono una (ulteriore) specializzazione.
La classe AL contiene l'efficienza dell'aliante (int) mentre la classe AM contiene la potenza (double) dell'aereo a motore.

Cercare di confrontare la potenza o l'efficienza degli aeromobili a livello della classe A si dimostra subito una soluzione impraticabile.

class Aero1{
public static void main (String args []) {
AL a=new AL("I-IVVL",40);
AL b=new AL("I-QCNK",39);
AM c=new AM("I-EAD",66.2);
AM d=new AM("I-CYKF",66.1);
System.out.println("a > b:"+a.superiore(b));
System.out.println("d > c:"+d.superiore(c));
System.out.println(a);
System.out.println(b);
}//fine main
}//fine classe aero
//--------------------------------------------
class A{
protected String sigla;
A(String s){ sigla=s; }
String getS(){return sigla;}
//!!! non sono visibili getf() e getpo() perchè appartengono
//ad oggetti discendenti dovrò...trovare altre soluzioni
public Boolean superiore (A x){
if(this instanceof AL && x instanceof AL){
   if(this.getf() > x.getf()){ return true; }else return false; }
else if(this instanceof AM && x instanceof AM){
   if(this.getpo() > x.getpo()) return true;
   else return false;
}else return false;
}//fine superiore

public String toString(){
String s="sigla: "+getS(); return s;
}
}//fine classe A
//-----
class AL extends A{
private int efficienza;
AL(String s,int eff){super(s);efficienza=eff;}
public int getf(){return efficienza;}
public String toString(){
String s="sigla:"; s+=getS()+" efficienza: "+getf();
return s; }
}//fine classe AL
//---------
class AM extends A{
private double potenza;
AM(String s,double Po){ super(s); potenza=Po; }
public double getpo(){return potenza;}
public String toString(){
String s="sigla:";
s+=getS()+"potenza: "+getpo(); return s;
}
}//fine classe AM

viene infatti prodotto il seguente errore:
aero1.java:24: cannot find symbol symbol :
method getf() location: class A
if(this.getf() > x.getf()){
Non funziona perchè i metodi gerf() e getpo() non sono visibili alla classe antenata A.
Occorre che siano le classi derivate AL e AM ad occuparsi di confrontare fra loro oggetti omologhi in base alla potenza o all'efficienza.
Lasciando invariato i main() la soluzione è la seguente:

// funziona perchè il metodo superiore()
//sta negli oggetti discendenti
class A{
protected String sigla;
A(String s){ sigla=s; }
String getS(){return sigla;}
public String toString(){
   String s="sigla: "+getS();
return s;
}
}//fine classe A
class AL extends A{
private int efficienza;
AL(String s,int eff){super(s); efficienza=eff; }
public int getf(){return efficienza;}
Boolean superiore (AL x){
   if(this.getf()>x.getf()) return true;
   else return false;
}//fine superiore
public String toString(){
   String s="sigla:"+getS()+"efficienza: "+getf();
return s;
}
}//fine classe AL
class AM extends A{
private double potenza;
AM(String s,double Po){ super(s); potenza=Po; }
public double getpo(){return potenza;}
Boolean superiore (AM x){
if(this.getpo()>x.getpo()) return true;
else return false;
}//fine superiore
public String toString(){
String s="sigla:"+getS()+"potenza: "+getpo();
return s;
}
}//fine classe AM

In quest'ultimo caso, lo schema è il seguente ed il programma è pienamente funzionante.

Le specifiche del problema impongono, comunque, la scrittura di una interfaccia CMP che dichiari la presenza dei metodi superiore() nelle classi implementate. Modifichiamo il programma nel modo seguente;

class Aero3{
public static void main (String args []) {
AL a=new AL("I-IVVL",40);
AL b=new AL("I-QCNK",39);
AM c=new AM("I-EAD",66.2);
AM d=new AM("I-CYKF",66.1);
System.out.println("a > b:"+a.superiore(b));
System.out.println("d > c:"+d.superiore(c));
System.out.println(a);
System.out.println(b);
System.out.println(c.eqcode(d));
}//fine main
}//fine classe aero
//--------------------------------------------
interface CMP {
public boolean superiore(A x);
} //fine interfaccia
//--------------------------------------------
class A {
protected String sigla;
A(String s){sigla=s;}//costruttore
String getS(){return sigla;}
public boolean eqcode(A x){
return this.sigla.equals(x.getS());
}//fine eqcode
public String toString(){
String s="sigla:"+getS();
return s;
}
}//fine classe A
//--------------------------------------------
class AL extends A implements CMP{
private int efficienza;
AL(String s,int eff){ super(s); efficienza=eff; }
public int getf(){return efficienza;}
public boolean superiore(A x){
   if(x instanceof AL ){
      if(this.efficienza > ((AL)x).getf())return true ;
      else return false ;
   }else return false;
}//fine superiore
public String toString(){
String s="sigla:"+getS()+"efficienza: "+getf();
return s;
}
}//fine classe AL
//--------------------------------------------
class AM extends A implements CMP{
private double potenza;
AM(String s,double Po){ super(s); potenza=Po; }
public double getpo(){return potenza;}
public boolean superiore(A x){
   if(x instanceof AM ){
      if(this.potenza > ((AM)x).getpo())return true ;
      else return false ;
   }else return false;
}//fine superiore
public String toString(){
String s="sigla:"+getS()+"potenza: "+getpo();
return s;
}
}//fine classe AM

Lo schema del programma ora, può essere riassunto come:

Le classi AL e AM implementano l'interfaccia CMP ed ereditano dalla classe A nella quale abbiamo aggiunto anche il metodo ;

public boolean eqcode(A x){
return this.sigla.equals(x.getS());
}//fine eqcode

Questo metodo controlla se le sigle degli aeromobili sono identiche; questa operazione è possibile a livello della classe A perché l'attributo sigla è qui disponibile. E' anche possibile che l'interfaccia CMP sia in cima alla gerarchia delle classi:

ma in tal caso la classe A, non implementando il metodo superiore() dell'interfaccia, deve essere dichiarata abstract.

interface CMP {
public boolean superiore(A x);
} //fine interfaccia
//--------------------------------------------
abstract class A implements CMP{
protected String sigla;
A(String s){sigla=s;}//costruttore
String getS(){return sigla;}
public boolean eqcode(A x){
return this.sigla.equals(x.getS());
}//fine eqcode
public String toString(){
String s="sigla:"; s+=getS(); return s; }
}//fine classe A
//--------------------------------------------
class AL extends A{
private int efficienza;
AL(String s,int eff){super(s);efficienza=eff;}
public int getf(){return efficienza;}
public boolean superiore(A x){
   if(x instanceof AL ){
      if(this.efficienza >((AL)x).getf())return true ;
      else return false ;
   }else return false;
}//fine superiore
public String toString(){
String s="sigla:";
s+=getS()+" efficienza: "+getf();
return s; }
}//fine classe AL
//--------------------------------------------
class AM extends A{
private double potenza;
AM(String s,double Po){ super(s); potenza=Po; }
public double getpo(){return potenza;}
public boolean superiore(A x){
   if(x instanceof AM ){
      if(this.potenza >((AM)x).getpo())return true ;
      else return false ;
   }else return false;
}//fine superiore
public String toString(){
String s="sigla:";
s+=getS()+"potenza: "+getpo();
return s;
}
}//fine classe AM