molteplicità in java

[Tommy86r]

Ragazzi ho cercato in rete ma non son riuscito a trovare quello che mi serve:
mi serve un pò di codice java (di esempio) che traduca un'associazione 1..* e un'associazione *..*
anche con i costruttori... esempi anche stupidi giusto per capire il funzionamento...

Vi ringrazio è molto importante per un esame che devo fare

[andbin]

Originariamente inviato da Tommy86r
mi serve un pò di codice java (di esempio) che traduca un'associazione 1..* e un'associazione *..*
anche con i costruttori...

Ma che vuol dire?! Non è che c'è 1 modo e basta per fare queste cose .... dipende (da vari fattori).

Pensandolo nella pura ottica OOP, se un oggetto X deve poter fare riferimento a più altri oggetti di tipo Y, alla fin fine vuol semplicemente dire che dentro X ci deve essere una "collezione" (intesa qui in senso generale) di riferimenti agli oggetti Y.
Che poi per questa "collezione" si usi un array o una collection (es. ArrayList, Vector o altro) .... beh, concettualmente non cambia nulla.

Caso tipico: Uno studente segue più corsi e un corso può essere seguito da più studenti. A livello di Java puoi quindi fare 2 classi Studente e Corso. Se a uno studente sono associati più corsi vorrà dire che in Studente ci potrebbe essere un campo di tipo es. ArrayList<Corso> che contiene la lista dei corsi. E dal lato opposto, in Corso una collezione es. ArrayList<Studente> che fa riferimento agli studenti del corso.

Ma questa è solo una ipotesi e poi comunque si devono fare tutta una serie di valutazioni a livello di "design" e quindi poi tecniche: si vuole "nascondere" la collezione all'esterno? Cioè fare in modo che in Studente ci siano solo metodi es. aggiungiCorso(Corso c), rimuoviCorso(Corso c) ecc.... senza che si possa avere/manipolare direttamente la collezione? O si vuole fornire all'esterno la collezione con es. ArrayList<Corso> getListaCorsi() ??

Ripeto, come riassunto: la questione principale è solo quella di usare appropriatamente delle "collezioni" di oggetti.

[Tommy86r]

ciao era questo che volevo sapere... al di là dell incapsulamento!
comunque premetto che non ho una grossa conoscenza di java... quindi mi chiedevo che differenza c è tra le parentesi < > e le quadre?

La questione che maggiormente mi interessa è come vengono istanziate le classi...
nel caso dello studente e corsi, cioè uno studente segue più corsi, viene una cosa del genere?

public class studente{
corso []mycorsi;

studente(){
mycorsi[i] = new corso(this);
}
}


public class corso{
studente seguito;

corso (studente stud){
seguito=stud;

}

scusate gli errori...
e nel caso di molti a molti? cioè anche i corsi sono seguiti da più studenti?

grazie

[andbin]

Originariamente inviato da Tommy86r
quindi mi chiedevo che differenza c è tra le parentesi < > e le quadre?

Le < > denotano i tipi parametrici. In Java 5 è stata introdotta una nuova funzionalità chiamata "generics", cioè la possibilità di definire classi "parametriche".
E da Java 5 tutte le collezioni sono state convertite per essere "generiche" e chiaramente sarebbe meglio sfruttare appunto questa funzionalità (anche se si possono comunque usare ancora le collezioni come non parametrizzate).

E per precisare: non è una questione di comparare tra < > (tipi parametrici) e le quadre (riferite ad array) .... sono due cose completamente diverse!

Originariamente inviato da Tommy86r
La questione che maggiormente mi interessa è come vengono istanziate le classi...
nel caso dello studente e corsi, cioè uno studente segue più corsi, viene una cosa del genere?

public class studente{
corso []mycorsi;

studente(){
mycorsi[i] = new corso(this);
}
}

public class corso{
studente seguito;

corso (studente stud){
seguito=stud;

}

No, non proprio (manca comunque parecchio nel codice sopra).

La questione del molti-a-molti è che X fa riferimento a Y che a sua volta fa riferimento a X. E per evitare loop strani o incongruenze quando si collegano tra di loro gli oggetti bisogna fare le cose in modo un po' accurato e sensato.

[Tommy86r]

[b]
No, non proprio (manca comunque parecchio nel codice sopra).

Potresti aggiustarmelo un pò? sono le chiamate dei costruttori che mi interessano molto, poi metodi e attributi li puoi lasciar stare...
Te ne sarei grato

[andbin]

Originariamente inviato da Tommy86r
sono le chiamate dei costruttori che mi interessano molto

A dire il vero, in questo caso, i costruttori dovrebbero solo consentire di passare e inizializzare i dati essenziali di Studente o Corso. Cioè es. nome/cognome per Studente e es. titolo per Corso.

Poi per aggiungere/rimuovere le "associazioni" andrebbero fatti metodi appositi. Ed è qui la questione principale, visto che un oggetto Studente e un Corso si referenziano tra di loro. Se però ti interessa solo la referenziabilità da uno all'altro e non anche il contrario è ovviamente più semplice.

[Tommy86r]

si è quello che in realtà vorrei capire...cioè come si referenziano tra loro?

[Tommy86r]

vi faccio leggere quello che ho appuntato io in aula, per quanto riguarda l'associazione molti a molti tra una classe A e una B:

public class A{
private Set[B] myBs;

public void addB (B aB){
myBs add(aB);
aBaddToSet(this);
}

}


public class B {
private Set<A> myAs;

public void addToSet (A aA){
myAs add(aA);
}

}

Siccome non mi è molto chiara qualcuno potrebbe aiutarmi a comprenderla ?
ringraziamenti anticipati al volontaro

[andbin]

Originariamente inviato da Tommy86r
Siccome non mi è molto chiara qualcuno potrebbe aiutarmi a comprenderla ?

Il tuo codice sopra, anche se non è completo/corretto, usa un Set che è un'altra tipologia di collezione. Prima, all'inizio, avevo parlato di ArrayList ma ovviamente bisogna vedere come deve essere trattato l'insieme degli oggetti.

Un ArrayList è una collezione la cui tipologia è una "lista", una sequenza di elementi ciascuno ad un certo "indice". Un Set invece è una collezione che rappresenta in generale un "insieme" di oggetti senza un ordine ben preciso (la interfaccia Set non indica nulla circa l'ordine ... sono le implementazioni specifiche che possono prescrivere un ordine, come es. TreeSet che è "sorted" quindi ordinato in base al contenuto degli elementi) e in cui non ci possono essere "duplicati".

Se vogliamo riscrivere il tutto in modo sensato facendo riferimento all'esempio Studente/Corso:

import java.util.*;

public class Prova {
    public static void main(String[] args) {
        Corso mat = new Corso("Matematica");
        Studente s1 = new Studente("Mario", "Rossi");
        Studente s2 = new Studente("Giacomo", "Verdi");

        s1.iscriviACorso(mat);
        mat.iscriviStudente(s2);

        Iterator<Studente> it = mat.iterator();

        while (it.hasNext()) {
            System.out.println("Studente iscritto: " + it.next());
        }
    }
}

class Studente {
    private String nome;
    private String cognome;
    private Set<Corso> corsi = new HashSet<Corso>();

    public Studente(String nome, String cognome) {
        this.nome = nome;
        this.cognome = cognome;
    }

    public void iscriviACorso(Corso c) {
        if (!corsi.contains(c)) {
            corsi.add(c);
            c.iscriviStudente(this);
        }
    }

    public String toString() {
        return nome + " " + cognome;
    }
}

class Corso {
    private String titolo;
    private Set<Studente> studenti = new HashSet<Studente>();

    public Corso(String titolo) {
        this.titolo = titolo;
    }

    public void iscriviStudente(Studente s) {
        if (!studenti.contains(s)) {
            studenti.add(s);
            s.iscriviACorso(this);
        }
    }

    public Iterator<Studente> iterator() {
        return studenti.iterator();
    }
}

Non è ovviamente il massimo, ci sarebbero delle cose da aggiungere per completare bene il codice. Ma è corretto.

[Tommy86r]

Grazie andbin, hai iniziato a schiarirmi le idee...
volevo chiederti ancora: private Set<Corso> corsi = new HashSet<Corso>();
questa istruzione inizializza un insieme di oggetti corso per ogni studente giusto?

ed ogni elemento di questo insieme viene inserito con l'istruz corsi.add(c)...

ultima cosa, non ho capito bene iterator cosa fa, è tipo un cursore che punta all'ultimo elemento dell'insieme? -.-