Gestione dei tavoli di un ristorante in Java con array dinamici

Esercizio 7

Scrivi un programma in grado di gestire le ordinazioni ai tavoli di un ristorante. Nel ristorante possono essere disposti dei tavoli, ciascuno qualificato da un id numerico e da un numero di coperti.
Per ciascun tavolo devono essere memorizzate le bevande ed i piatti consumati, in automatico deve poter essere calcolato il conto da pagare.
I piatti e le bevande disponibili, sono invece memorizzati in una classe 'Menu' che li suddivide in due categorie (piatti e bevande, appunto).
Ogni piatto o bevanda deve essere qualificato da un identificatore univoco alfanumerico (nome) e dal suo prezzo.

Ogni piatto o bevanda è dunque qualificato da un nome e da un costo; viene dunque predisposta la classe E (elemento generico) negli oggetti istanziati della quale possono essere memorizzate indifferentemente dei piatti o delle bibite.

class E {
private String nome; private int prezzo;
E(String id,int prz){nome=id;prezzo=prz;}//costruttore
public String getNom() {return nome;}
public int getPrz() {return prezzo;}
}

La classe è dotata dei metodi 'get' per la restituzione dei valori mentre l'ingresso dei valori viene fatto al momento dell'istanziazione, tramite il costruttore.
Un'operazione più impegnativa è la costruzione di un menu consultabile. La classe Menu è dotata di due attributi.

private E Piatti[];
private E Bevande[];

Si tratta di due vettori di oggetti della classe E, uno che contiene i piatti a l'altro le bevande disponibili del menu. I due metodi pubblici

void mostraP()
void mostraB()

non fanno altro che stampare a video i due vettori. Ulteriori due metodi pubblici:

E getP(int j) {return Piatti[j];}
E getB(int j) {return Bevande[j];

restituiscono l'elemento j-esimo di ciascun vettore.
Si noterà come sia il costruttore stesso a inserire i dati nel menu al momento della istanziazione di un oggetto della classe Menu .

La classe Tavolo deve memorizzare l'identificativo numerico dello stesso, il numero dei coperti, la lista delle vivande consumata e il saldo totale, attraverso gli attributi.

private int id,nCoperti,saldo;
private ArrayList lista;

il costruttore.

Tavolo(int i,int nCop)

si occupa solo di dare un id e un numero di coperti al tavolo stesso appena creato; la lista dei piatti ordinata è vuota. Per essa è previsto l'uso di un ArrayList, perché a priori non sono note quante portate si mangeranno i clienti. Il metodo

void ins(E e)

inserisce un elemento della lista indipendentemente dal fatto che si tratti di un piatto o di una bibita. Ovviamente è presente un metodo

private int calcolaSaldo()

per calcolare il tempo reale il conto.
Un metodo String toString() si occuperà di stampare tutti i dati pertinenti ad un tavolo.
Per ridurre il numero complessivo di righe noi eseguiamo il programma considerando un solo tavolo istanziato dall'istruzione:

Tavolo t1 = new Tavolo(1,3);

un ciclo do-while si occupa poi di aggiungere alla lista delle vivande ordinate al tavolo i vali piatti o bevande selezionate dal menu. .

import java.util.Scanner;
import java.util.ArrayList;
class Ristorante{ public static void main (String args []) {
int j,pre=0;
char ch;
String nome="";
Tavolo t1 = new Tavolo(1,3);
Menu menu=new Menu();
//-------------------------------------
do{
   System.out.print("Bevanda, Piatto o eXit (p/b/x)?:");
   Scanner q=new Scanner(System.in);
   ch=q.nextLine().charAt(0);
   if(ch=='p')menu.mostraP();
   else if(ch=='b')menu.mostraB();
   else break;
   System.out.print("ins.index:");
   j=q.nextInt();
   if(ch=='p'||ch=='b'){
   if(ch=='p'){
      nome=menu.getP(j).getNom();
      pre=menu.getP(j).getPrz();
   } else {
      nome=menu.getB(j).getNom();pre=menu.getB(j).getPrz();}
   E e=new E(nome,pre);
   t1.ins(e);
}
}while(ch!='x');
//-------------------------------------
System.out.println(t1);
}//fine main
}// fine classe Ristorante

class Tavolo {
private int id,nCoperti,saldo;
private ArrayList lista;
Tavolo(int i,int nCop){//costruttore
id=i;nCoperti=nCop; saldo=0;
ArrayList l=new ArrayList(0); lista=l; }//fine costruttore
public void ins(E e){
if (e.getPrz()!=0)lista.add(e);
}//fine ins
private int calcolaSaldo(){
int tot=0;
for(int i=0;i < lista.size();i++)tot+=((E)lista.get(i)).getPrz();
return tot;
}
public int getId() {return id;}
public int getNcop() {return nCoperti;}
public int getSaldo() {
saldo=calcolaSaldo();
return saldo;
}
public String getLista() {
String s="\n";
for(int i=0;i < lista.size();i++){
   s+=((E)lista.get(i)).getNom();
   s+="-"+((E)lista.get(i)).getPrz()+"\n";
} return s;
}
public String toString(){
return getId() + ":"+getNcop() + ":"+ getLista()+"\nsaldo:"+getSaldo();
}
}//fine classe Tavolo
//----------------------------------------------
class E {
private String nome;
private int prezzo;
E(String id,int prz){ //costruttore
nome=id; prezzo=prz;
}//fine costruttore
public String getNom() {return nome;}
public int getPrz() {return prezzo;}
}//fine classe E (elemento generico)
//-------------------------------------------------
class Menu {
private E Piatti[];
private E Bevande[];
Menu(){//costruttore
E p1=new E("spaghetti",4);
E p2=new E("pizza",3);
E p3=new E("verdura",2);
E p4=new E("pesce",5);
E p5=new E("carne",2);
E p[]={p1,p2,p3,p4,p5};
Piatti=p;
E b1=new E("acqua",1);
E b2=new E("vino",3);
E b3=new E("birra",2);
E b[]={b1,b2,b3};
Bevande=b;
}//fine costruttore
public E getP(int j) {return Piatti[j];}
public E getB(int j) {return Bevande[j];}
public void mostraP() {
for(int i=0;i < Piatti.length;i++)
   System.out.println(i+"."+Piatti[i].getNom());
}
public void mostraB(){
for(int i=0;i < Bevande.length;i++)
    System.out.println(i+"."+Bevande[i].getNom());
}
}//fine menu