[JAVA] difficoltà con l'uso degli array composti da oggetti

[sappe]

Salve a tutti, scrivo perché ho dei problemi con degli esercizi di java, e credo che questo sia dovuto alla mia mancata comprensione dell'utilizzo dei costruttori e degli array di oggetti.
Dato l'esercizio:

Scrivere una classe Dipendente che estende la classe Persona vista a lezione. Ogni dipen-dente ha un proprio anno di assuzione e un proprio stipendio. Si deniscano costruttori e vari metodi
get e set opportuni. Si ridenisca inoltre il metodo visualizza() opportunamente. Si denisca inoltre
un metodo guadagnaPiuDi che prende come parametro un altro oggetto Dipendente e restituisce true
se l'oggetto corrente ha uno stipendio maggiore di quello ricevuto come parametro, o false altrimenti.
Per testare la classe, scrivere un programma UsaDipendente che crea tre oggetti della classe Dipendente
e li visualizza in ordine di stipendio (usando il nuovo metodo per confrontare gli stipendi).

Questa è la classe Persona:

public class Persona {private String nome ; // nome e cognome
private String indirizzo ; // indirizzo
// costruttore
public Persona ( String nome , String indirizzo ) {
this . nome = nome ;
this . indirizzo = indirizzo ;
}
public String getNome () { return nome ; }
public String getIndirizzo () { return indirizzo ; }
public void setIndirizzo ( String indirizzo ) {
this . indirizzo = indirizzo ;
}
// visualizza i dati della persona
public void visualizza () {
System . out . println (" Nome : " + nome );
System . out . println (" Indirizzo : " + indirizzo );
System . out . println ();
}
}

e questa la mia soluzione:

public class Dipendente extends Persona {        private int annoAss;
        private int stipendio;
        //array che contiene i dipendenti
        //private Persona[] dipendenti;
        
        //costruttore dei dipendenti
    public Dipendente(String nome, String indirizzo, int annoAss, int stipendio) {
        super(nome, indirizzo);
        this.annoAss = annoAss;
        this.stipendio = stipendio;
        }


        public int getAnnoAss() {
            return annoAss; 
            }
        public int getStipendio() {
            return stipendio; 
            }
        public void visualizza() {
            System.out.println (" Nome: Dipendente " + getNome ());
            System.out.println (" Indirizzo: " + getIndirizzo ());
            System.out.println (" Anno di assunzione: " + annoAss);
            System.out.println (" Stipendio: " + stipendio);
            System.out.println ();
            }
/*metodo guadagnaPiuDi che prende come parametro un altro oggetto Dipendente e restituisce true
se l'oggetto corrente ha uno stipendio maggiore di quello ricevuto come parametro, o false altrimenti.*/
        public boolean guadagnaPiuDi(int a, int b){
            if (a > b) {
                return true;
            }
            else return false;
        }
}

public class UsaDipendente {
public static void main (String[] args){
    Dipendente d1 = new Dipendente("Mario Rossi", "via Inghilterra 12", 2009, 1400);
    Dipendente d2 = new Dipendente("Luigi Bianchi", "via Danimarca 23", 2005, 1700);
    Dipendente d3 = new Dipendente("Peach Rosa", "via Svezia 34", 2012, 1500);
    
    if (d1.guadagnaPiuDi(d1.getStipendio(), d2.getStipendio()) &&
            d1.guadagnaPiuDi(d1.getStipendio(), d3.getStipendio())
            && d2.guadagnaPiuDi(d2.getStipendio(), d3.getStipendio())){
        d1.visualizza();
        d2.visualizza();
        d3.visualizza();
    }
    else if (d1.guadagnaPiuDi(d1.getStipendio(), d3.getStipendio()) && 
            d3.guadagnaPiuDi(d3.getStipendio(), d2.getStipendio()) && 
            d1.guadagnaPiuDi(d1.getStipendio(), d2.getStipendio())){
        d1.visualizza();
        d3.visualizza();
        d2.visualizza();
    }
    else if (d2.guadagnaPiuDi(d2.getStipendio(), d1.getStipendio()) &&
        d1.guadagnaPiuDi(d1.getStipendio(), d3.getStipendio()) &&
        d2.guadagnaPiuDi(d2.getStipendio(), d3.getStipendio())){
        d2.visualizza();
        d1.visualizza();
        d3.visualizza();
    }
    else if (d2.guadagnaPiuDi(d2.getStipendio(), d1.getStipendio()) && 
            d2.guadagnaPiuDi(d2.getStipendio(), d3.getStipendio()) &&
            d3.guadagnaPiuDi(d3.getStipendio(), d1.getStipendio())){
        d2.visualizza();
        d3.visualizza();
        d1.visualizza();
    }
    else if (d3.guadagnaPiuDi(d3.getStipendio(), d1.getStipendio()) &&
            d3.guadagnaPiuDi(d3.getStipendio(), d2.getStipendio()) &&
            d1.guadagnaPiuDi(d1.getStipendio(), d2.getStipendio())){
        d3.visualizza();
        d1.visualizza();
        d2.visualizza();
    }
    else {
        d3.visualizza();
        d2.visualizza();
        d1.visualizza();
    }
}
}

Che funziona, ma è inutilmente lunga e contorta, e peggio ancora non funzionerebbe con più dipendenti.
Cosa so di star sbagliando: per risolvere un esercizio del genere ovviamente devo utilizzare un loop su di un array di oggetti per ordinarlo, però proprio non capisco come fare, e sto andando a casaccio. Continuo a rileggere le lezioni e nel libro, cerco esempi ma non ne vengo a capo.
Io devo creare nella mia classe Dipendente che estende Persona un array che contenga gli oggetti dipendenti, giusto?

private Persona[] dipendenti;

Nel costruttore lo inizializzo:

this.dipendenti = new Dipendente1[100]; //numero massimo di dipendenti a caso

Nel mio metodo guadagnaPiuDi devo far capire al compilatore che voglio prendere due oggetti dipendente e confrontarli tra loro, restituendo true o false a seconda del risultato del confronto: come faccio a dirgli che voglio selezionare due oggetti dipendente?
Ho ipotizzato, provando varie cose su eclipse, una soluzione del genere:

   public boolean guadagnaDiPiu2(Persona dipendente){    if (this.stipendio > stipendio) {
                return true;
            }
            else return false;
        }


}

ma non mi sembra sensato (il compilatore tra cosa fa i confronti??), e comunque in questo modo ho difficoltà a scrivere una soluzione per UsaDipendenti.
Avete suggerimenti, fonti dalla quale posso trarre esempi, approfondimenti (anche in inglese) che dovrei leggere? Perché sto cercando ma non trovo niente di utile per aiutarmi a comprendere spero di non aver posto domande troppo stupide e vi ringrazio in anticipo per la vostra disponibilità ^_^

[andbin]

Questa è la classe Persona:

La classe Persona, sebbene non l'hai scritta (perlomeno come si vede postata qui) granché bene come stile, tecnicamente è ok.

Che funziona, ma è inutilmente lunga e contorta, e peggio ancora non funzionerebbe con più dipendenti.
Cosa so di star sbagliando: per risolvere un esercizio del genere ovviamente devo utilizzare un loop su di un array di oggetti per ordinarlo

Sì, è contorto ed abbastanza inutile. In Java l'ordinamento degli oggetti secondo il Collections Framework si basa sulle interfacce Comparable/Comparator. E in tal senso dovresti agire a meno che ti sia stato esplicitamente chiesto di implementare da zero un algoritmo di ordinamento invece di usare quello implementato nel framework.

Io devo creare nella mia classe Dipendente che estende Persona un array che contenga gli oggetti dipendenti, giusto?

Dipende ... se intendi che un dipendente è es. un "manager" ed ha N dipendenti sottoposti, allora sì. Ma in tal caso forse sarebbe ancora più appropriato derivare ancora e definire es. Manager extends Dipendente e allora sì, in Manager avrebbe assolutamente senso avere i riferimenti ai "dipendenti".


P.S. prima di continuare, approfondisci la questione dell'ordinamento.

[sappe]

Ti ringrazio della risposta e del suggerimento (che sto guardando e voglio approfondire), ma quello che l'esercizio chiedeva è la costruzione di un metodo che dia come risultato del confronto true o false, e da lì stilare una lista ordinata.
Il problema per me non è trovare un metodo per riordinare gli oggetti, ma richiamarli all'interno dei metodi o dei comandi da eseguire!
Faccio un altro esempio di esercizio che non riesco a risolvere, dato che l'ho compreso meglio (l'ho costruito da capo) ma mi blocco nello stesso punto:

Scrivere una classe Veicolo che prevede una targa, una marca e un modello. La classeprevede anche una variabile booleana che descrive se il veicolo e guasto. Aggiungere un costruttore op-
portuno e vari metodi get e set opportuni. Scrivere la classi Vettura e Motociclo che estendono la classe
Veicolo. La classe Vettura prevede una stringa che ne descrive la tipologia ("utilitaria","station wagon",
"SUV",....) mentre la classe Motociclo prevede un numero che ne descrive la cilindrata (50, 125, ....).
Per testare le classi, scrivere un programma UsaVeicoli che crea un array inizializzato con veicoli
delle varie tipologie. Alcuni dei veicoli inseriti nell'array dovranno diventare guasti. Il programma deve
stampare la lista delle targhe dei veicoli guasti.

La classe Veicolo:

public class Veicolo {	private int targa;
	private String marca;
	private String modello;
	private boolean guasto;
	
	//inserire costruttore
	public Veicolo (int targa, String marca, String modello, boolean guasto){
		this.targa = targa;
		this.marca = marca;
		this.modello = modello;
		this.guasto = guasto;
	}
	//get informazioni
	public int getTarga(){ return targa; }
	public String getMarca() { return marca; }
	public String getModello() { return modello; }
	public boolean getGuasto() { return guasto; }
	
	int capienzaArray = 100;
	Veicolo[] veicoliV = new Veicolo[capienzaArray];


	public void stampaTarga(){
		System.out.println("Questo veicolo è guasto: " + getTarga());
	}
}

la classe motociclo:

public class Motociclo extends Veicolo {		private int cilindrata;


//costruttore
	public Motociclo(int targa, String marca, String modello, boolean guasto, int cilindrata) {
		super(targa, marca, modello, guasto);
		// TODO Auto-generated constructor stub
		this.cilindrata = cilindrata;
	}
public int getCilindrata() { return cilindrata; }
}

la classe vettura:

public class Vettura extends Veicolo {		private String tipologia;
		
	//costruttore
	public Vettura(int targa, String marca, String modello, boolean guasto, String tipologia) {
		super(targa, marca, modello, guasto);
		this.tipologia = tipologia;
		// TODO Auto-generated constructor stub
	}
	public String getTipologia(){ return tipologia; }
}

e mi blocco al programma UsaVeicoli, che nel mio cervello dovrebbe essere qualcosa del genere (lasciando perdere per ora la randomizzazione del guasto):

public class UsaVeicoli {	public static void main ( String args []) {


		/*tutti questi oggetti entrano a far parte dell'array veicoliV, giusto? Perché io ho creato un array di tipo Veicolo[], chiamato veicoliV, ma dato che Motociclo e Vettura sono sottoclassi di Veicolo sono automaticamente incluse*/
		Motociclo mot1 = new Motociclo(4853, "Audi", "smart", false, 150);
		Veicolo veic1 = new Veicolo(7683, "Fiat", "panda", false);
		Vettura vett1 = new Vettura(67894, "Volvo", "sportivo", true, "SUV");


		/*perché non posso usare veicoliV.length? Se veivoliV è un array, dovrei poter interagire su di esso e sulle sue posizioni, no? Perché non posso?*/
		for (int i= 0; i < 3; i++){
			if (veicoloV[i] == true){
					veicoloV[i].stampaTarga();
				}
		}
	}
}

Nell'esempio credo si veda bene che non ho capito come costruire e usare un oggetto e un array di oggetti. Sto davvero iniziando a confondermi.

[andbin]

/*perché non posso usare veicoliV.length? Se veivoliV è un array, dovrei poter interagire su di esso e sulle sue posizioni, no? Perché non posso?*/

Il punto è che veicoliV è un campo "di istanza" di Veicolo, quindi ciascuna istanza di Veicolo (o sottoclasse) ha il suo array. E quindi ha senso? Direi proprio di no!

[sappe]

Il punto è che veicoliV è un campo "di istanza" di Veicolo, quindi ciascuna istanza di Veicolo (o sottoclasse) ha il suo array. E quindi ha senso? Direi proprio di no!

Scusami, io è giorni che continuo a studiarmi e ristudiarmi questi argomenti, e continuo a confondermi sempre di più. Mi puoi dare per favore degli esempi validi di esercizi simili se li conosci? O farmi anche un esempio di risoluzione generale di un esercizio simile?
Non ti chiedo di risolvermi questo ovviamente, però dall'esempio che ci ha dato il professore non riesco a ricavare soluzioni simili.
Non riesco proprio a capire come aggiungere gli oggetti che creo a un array che posso utilizzare.
Ti mostro gli esempi del professore: estendendo la classe persona ha creato le classi Professore e Studente (che ometto, sono simili a esempi standard che si trovano in giro). Poi ha creato la classe Spettacolo:

public class Spettacolo {private String titolo ; // titolo dello spettacolo
private String compagnia ; // compagnia teatrale
private String dataora ; // data e ora spettacolo
// array che contiene gli spettatori ( classe Persona )
private Persona [] spettatori ;
// contatore dei posti prenotati ( inizialmente zero )
private int postiPrenotati = 0;
// costante condivisa che indica la capienza del teatro
private static final int CAPIENZA =100;
// costruttore
public Spettacolo ( String titolo , String compagnia ,
String dataora ) {
this . titolo = titolo ;
this . compagnia = compagnia ;
this . dataora = dataora ;
// inizializza l'array ( inizialmente pieno di null )
this . spettatori = new Persona [ CAPIENZA ];
}
//restituisce il numero di posti ancora disponibili
public int postiDisponibili () {
return CAPIENZA - postiPrenotati ;
}
//consente di prenotare un nuovo posto
//restituisce false se non ci sono posti disponibili
public boolean prenota ( Persona spettatore ) {
if ( postiDisponibili () >0) {
spettatori [ postiPrenotati ] = spettatore ;
postiPrenotati ++;
return true ;
}
else return false ;
}
//stampa l'elenco delle prenotazioni
public void stampaPrenotazioni () {
System . out . println (" Spettacolo " + titolo );
System . out . println (" Del " + dataora );
System . out . println (); // riga vuota
for (int i =0; i< postiPrenotati ; i ++) {
spettatori [i]. visualizza ();
}
}
}

e la classe UsaSpettacolo2:

public class UsaSpettacolo2 {public static void main ( String args []) {
// crea una persona , uno studente e un professore
Persona pers = new Persona (" Mario Rossi ","Via Garibaldi 23");
Studente stud = new Studente (" Gianni Bianchi "," Via Gramsci 88");
Professore prof = new Professore (" Luca Neri "," Via Belli 11",
" a11233 "," Dip . Matematica ");
// crea uno spettacolo
Spettacolo s = new Spettacolo (" Macbeth "," Attori dilettanti ",
" 25/12/2013 - 21.00 ");
// prenota posti per tutti
boolean ok1 = s. prenota ( pers );
boolean ok2 = s. prenota ( stud );
boolean ok3 = s. prenota ( prof );
// controlla che sia andato tutto bene
if (! ok1 || ! ok2 || ! ok3 ) System . out . println (" Problemi ...");
// stampa l'elenco delle prenotazione
s. stampaPrenotazioni ();
// stampa i posti ancora disponibili
System . out . println (" Posti disponibili : " +s. postiDisponibili ());
}
}

Io partendo da questi esempi non riesco a risolvere gli esercizi, cioè non riesco ad astrarre come aggiungere gli elementi che ho creato all'array; logicamente, leggendo e provando gli esercizi che ha dato, lo capisco, ma non credo riesco ad applicarlo in altri contesti! Non posso creare un array in UsaVeicoli (come chiede l'esercizio, tra l'altro), o posso?
Guardando l'esempio del professore ho cercato un po' di riscrivere le mie classi, ma arrivo sempre a non saper scrivere UsaVeicoli, incollo solo la classe Veicolo e la classe UsaVeicoli dato che Motociclo e Vettura non cambiano:

import java.util.Random;public class Veicolo {
    private int targa;
    private String marca;
    private String modello;
    private boolean guasto;
    Random random = null;
    private static final int numVeicoli =100;
    private int postiInOfficina = 0;
    //inserire costruttore
    
    private Veicolo[] veicoli;
    
    
    
    public Veicolo (int targa, String marca, String modello, boolean guasto){
        this.targa = targa;
        this.marca = marca;
        this.modello = modello;
        this.guasto = guasto;
        this.veicoli = new Veicolo[numVeicoli];


    }
    //get informazioni
    public int getTarga(){ return targa; }
    public String getMarca() { return marca; }
    public String getModello() { return modello; }
    public boolean getGuasto() { return guasto; }
    
    public boolean randomGuasto() {
        guasto = random.nextBoolean();
        return guasto;
    }
    
    public int postiDisponibili () {
        return numVeicoli - postiInOfficina;
        }
    
    public void stampaTarga(){
        if (guasto == true){
        System.out.println("Questo veicolo è guasto: " + getTarga());
        }
    }


//inserisci nell'array di Veicoli
public boolean inserisci(Veicolo veicoliV) {
if ( postiDisponibili () >0) {
veicoli[postiInOfficina] = veicoliV;
postiInOfficina++;
return true ;
}
else return false ;
}
//stampa l'elenco dei veicoli
public void stampaElencoVeicoli() {
    System.out.println("Elenco delle targhe dei veicoli guasti:");
for (int i =0; i< postiInOfficina; i ++) {
veicoli [i].stampaTarga();
}
}
}

public class UsaVeicoli {    public static void main ( String args []) {
        


        
        Veicolo v1 = new Veicolo(54627, "Fiat", "Panda", false);
        Motociclo mot1 = new Motociclo(4853, "Audi", "smart", false, 150);
        Veicolo veic2 = new Veicolo(7683, "Fiat", "panda", false);
        Vettura vett1 = new Vettura(67894, "Volvo", "sportivo", true, "SUV");
        
        boolean ok1 = veicoliV.inserisci(v1);//e veicoliV è sempre sbagliato, o qualsiasi altra cosa provi a scriverci :(
        
    }
}

Grazie in anticipo se vorrai aiutarmi, e della tua pazienza spero di essermi spiegata bene!

[andbin]

public class Spettacolo {
    // ....
    private Persona [] spettatori ;
    private int postiPrenotati = 0;
    private static final int CAPIENZA =100;

    public Spettacolo ( String titolo , String compagnia , String dataora ) {
        // ....
        this . spettatori = new Persona [ CAPIENZA ];
    }

    public int postiDisponibili () {
        return CAPIENZA - postiPrenotati ;
    }

    public boolean prenota ( Persona spettatore ) {
        if ( postiDisponibili () >0) {
            spettatori [ postiPrenotati ] = spettatore ;
            postiPrenotati ++;
            return true ;
        }
        else return false ;
    }

    // ....
}

Ho quotato nel codice solo le parti rilevanti. Il concetto che hai applicato per gestire l'insieme delle Persone per lo Spettacolo, è sensato e corretto!

Cioè tenere un array, tenere il numero "logico" di elementi occupati e poi nel prenota assegnare il Persona al posto corrente e aumentare il numero di posti prenotati (che sarà l'indice del successivo Persona).
Tutto questo ti ripeto che l'hai fatto giusto. Se non si usano le "collezioni", questo è il modo basilare e minimale per gestire un insieme di oggetti che cresce con un limite fisico massimo (se volessi che sia espandibile a piacere in modo arbitrario, chiaramente serve altra logica in più ma sicuramente non è l'obiettivo degli esercizi che stai facendo).

La questione della classe Veicolo è diversa, principalmente a livello concettuale. Una classe Veicolo denota una singola entità, appunto 1 veicolo. Non ha senso che Veicolo contenga un array di N veicoli. Invece una classe es. Garage o Parcheggio ha senso che abbia N veicoli. E li puoi gestire esattamente come hai fatto per Spettacolo, che ti ribadisco, è appropriata come gestione.


P.S. cura solo di più lo stile di scrittura. Vedo "troppi" spazi superflui.

[sappe]

Ho quotato nel codice solo le parti rilevanti. Il concetto che hai applicato per gestire l'insieme delle Persone per lo Spettacolo, è sensato e corretto!

Ci credo è corretto, è quello che ci ha dato il professore come esempio

Tutto questo ti ripeto che l'hai fatto giusto. Se non si usano le "collezioni", questo è il modo basilare e minimale per gestire un insieme di oggetti che cresce con un limite fisico massimo (se volessi che sia espandibile a piacere in modo arbitrario, chiaramente serve altra logica in più ma sicuramente non è l'obiettivo degli esercizi che stai facendo).

La questione della classe Veicolo è diversa, principalmente a livello concettuale. Una classe Veicolo denota una singola entità, appunto 1 veicolo. Non ha senso che Veicolo contenga un array di N veicoli. Invece una classe es. Garage o Parcheggio ha senso che abbia N veicoli. E li puoi gestire esattamente come hai fatto per Spettacolo, che ti ribadisco, è appropriata come gestione.

La cosa che mi creava dubbi principalmente era che il professore non aveva minimamente accennato ad altre classi nel testo dell'esercizio beh l'ho risolto, grazie al tuo consiglio che mi ha permesso di arrivare ad una soluzione più logica per i posteri, ecco la soluzione con una classe Garage:

public class Garage {
	private Veicolo[] garage;
	private int postiOccupati = 0;
	private static final int CAPIENZA =100;
	public Garage(){
		this.garage = new Veicolo[CAPIENZA];
	}
	public int postiDisponibili () {
		return CAPIENZA - postiOccupati;
		}
	
	public boolean occupa(Veicolo postoLibero) {
		if ( postiDisponibili () >0) {
		garage[postiOccupati] = postoLibero;
		postiOccupati++;
		return true ;
		}
		else return false ;
		}
	//stampa l'elenco dei veicoli
	public void stampaElencoVeicoli() {
		System.out.println("Elenco delle targhe dei veicoli guasti:");
	for (int i =0; i< postiOccupati; i ++) {
	garage[i].stampaTarga();
	}
	}
	
}

public class UsaVeicoli {
	public static void main ( String args []) {
		
		Garage g = new Garage();
		
		Veicolo v1 = new Veicolo(54627, "Fiat", "Panda", false);
		Motociclo mot1 = new Motociclo(4853, "Audi", "smart", false, 150);
	    Veicolo veic2 = new Veicolo(7683, "Fiat", "panda", false);
	    Vettura vett1 = new Vettura(67894, "Volvo", "sportivo", true, "SUV");
		
	    boolean ok1 = g.occupa(v1);
	    boolean ok2 = g.occupa(mot1);
	    boolean ok3 = g.occupa(veic2);
	    boolean ok4 = g.occupa(vett1);
	    
	    if (!ok1 || !ok2 || !ok3 ){
	    	System.out.println("Ci sono dei problemi con i tuoi veicoli!");
	    }
	    
	    g.stampaElencoVeicoli();
	    
	}
}

Ovviamente la classe Veicolo cambia di conseguenza, e al suo interno si tolgono tutte le porzioni di codice che servono a creare un array, che sono nel garage.

Grazie ancora della tua disponibilità e del tuo aiuto!

[andbin]

Prego. Come suggerimento, per migliorare Garage, fai in modo che possa essere istanziato passando una capienza. Puoi anche offrire entrambi i modi: se istanziato senza capienza, usa quella predefinita (la costante interna); se istanziato con una capienza esplicita, usa questa.
Nulla di che ovviamente, ma almeno dimostri di aver fatto qualcosa di più flessibile.