Gestione delle date in java e liste

[valia]

publicUtente(String nome,String cognome,String nickname,Date dataNascita,Utente utentePresentante)

questo è l'unico costruttore che devi avere.

poi, quando hai da istanziare il founder

private static final String FOUNDER = "founder"; 
Utente founder = new Utente ("fondatore" , "fondatore", "fondatore", "25/10/2013", FOUNDER);

[Jamie04]

publicUtente(String nome,String cognome,String nickname,Date dataNascita,Utente utentePresentante)

questo è l'unico costruttore che devi avere.

poi, quando hai da istanziare il founder

private static final String FOUNDER = "founder"; 
Utente founder = new Utente ("fondatore" , "fondatore", "fondatore", "25/10/2013", FOUNDER);

in pratica hai fatto in modo che il fondatore abbia un riferimento a se stesso, che non è un oggetto utente ma una costante statica...
non funziona, perché il costruttore prevede che per istanziare un oggetto ci deve un riferimento a un campo utente, non a una stringa (FOUNDER è una stringa!)
comunque questa cosa l'ho risolta, magari non brillantemente, ma ora va. solo che sono costretta a istanziare il fondatore per forza nella classe utente e non in quella di test.

ora dovrei fare in modo di inserire un controllo che faccia in modo che un utente può presentarne uno ed uno soltanto. quindi ogni utente può essere presentatore di un solo utente. un if nel costruttore?

grazie comunque...

[andbin]

Ehm...non ricordavo nemmeno che i costruttori potessero essere privati!

Sì, certo che possono.

Vediamo se ho capito bene quello che hai detto:

public class Utente {
    private static final Utente FOUNDER=new Utente("Alan", "Turing", "Fondatore", new Date(12,5,23));
    
    //costruttore founder
    private Utente (String nome, String cognome, String nickname, Date dataNascita) {

Il primo problema che mi si presenta è: come faccio a riferirmi a FOUNDER all'esterno di questa classe?
Cioè, nella classe UtenteTest dove creo gli utenti del social network, il primo utente che creo come fa ad aver FOUNDER come utentePresentante?
[...]
invece ho capito che per riferirmi a FOUNDER nell'altra classe dovevo anteporre il nome della classe in cui risiede FOUNDER.

Guarda che come stavi facendo è (quasi) tutto giusto, salvo il fatto che FOUNDER va messo public, altrimenti è ovvio che dall'esterno non è visibile.

Una costante static può avere anche senso che sia privata, se serve solo internamente a quella classe ..... ma non è questo il tuo caso. E in altre classi va appunto usata come Utente.FOUNDER.

Sono comunque in panne, ora non so come impedire che si istanzi un oggetto utente senza che abbia un riferimento a un utente presentante. Avevo pensato di risolvere col costruttore così fatto:

    //costruttore utente
    public Utente (String nome, String cognome, String nickname, Date dataNascita, Utente utentePresentante) {

Anche qui è (quasi) tutto giusto, tecnicamente. Il costruttore è giusto questo per creare un utente con un utente "presentante". Il fatto però è che devi testare utentePresentante e se null dovresti lanciare una eccezione, a tua scelta NullPointerException o IllegalArgumentException o una tua eccezione specifica (se vuoi o se richiesto).

Ma a quanto pare non funziona comunque, perché se provo a creare un utente senza rif. a chi lo presenta, molto semplicemente non trova il costruttore e mi dà un errore.

Non capisco il problema .... il costruttore è pubblico, se passi i parametri corretti come quantità, tipi, non vedo problemi.

solo che sono costretta a istanziare il fondatore per forza nella classe utente e non in quella di test.

Tecnicamente, di per sé, non c'è nulla di strano in quella costante. Come posto/momento di creazione è appropriata. Se ti lamenti del fatto che i dati nome, cognome ecc... devi per forza "cablarli" in Utente quando istanzi l'utente per FOUNDER ..... allora sì, ti do ragione.

Una soluzione è usare un metodo di "factory", in Utente metti un metodo statico creaFounder che riceve i dati nome ecc... e ovviamente creaFounder deve poter creare 1 solo fondatore, quindi un campo static per il fondatore lo devi comunque tenere.

ora dovrei fare in modo di inserire un controllo che faccia in modo che un utente può presentarne uno ed uno soltanto. quindi ogni utente può essere presentatore di un solo utente. un if nel costruttore?

Qui allora o cambi radicalmente la architettura, ovvero crei una entità (=classe) SocialNetwork che contiene tutte le informazioni e associazioni tra utenti necessarie (e Utente modella solo più nome+cognome+nickname+dataNascita e basta).
Oppure ...

Tenendo la tua architettura attuale, in Utente aggiungi anche la informazione di utentePresentato (non solo utentePresentante). Perché? Pensaci .... così puoi legare i due utenti presentato e presentatore.
Quando crei un nuovo utente passando un "presentatore" fai in modo che il utentePresentato di presentatore faccia riferimento al this del nuovo utente che stai creando. Così sono legati e se successivamente si tenta di creare un nuovo utente con quello stesso "presentatore", puoi verificare che il suo utentePresentato sia null o no.


P.S. come ti è già stato detto, java.util.Date non è di per sé "deprecato" ... anzi, è una classe tutt'oggi ancora molto importante. Sono molti dei suoi metodi/costruttori che sono deprecati. Quindi non fare new Date(12,5,23).
Se vuoi costruire facilmente un Date con g/m/a, fai una classe di utility es. DateUtils con un metodo statico che riceve g/m/a (in qualunque modo ti pare, int separati o anche in stringa unica) e crei un Date passando o da un parsing con (Simple)DateFormat (se parti con un String) o con un GregorianCalendar (se passi int separati).

[Jamie04]

Sì, certo che possono.
Anche qui è (quasi) tutto giusto, tecnicamente. Il costruttore è giusto questo per creare un utente con un utente "presentante". Il fatto però è che devi testare utentePresentante e se null dovresti lanciare una eccezione, a tua scelta NullPointerException o IllegalArgumentException o una tua eccezione specifica (se vuoi o se richiesto).

Allora nel frattempo ho mandato le classi al prof che mi ha detto che va bene come ho (abbiamo ) fatto finora, eccetto che l'utente FOUNDER deve essere creato nella classe di test e non nella classe Utente...e allora torno al problema iniziale (in effetti questa tecnica di crearlo nella classe utente mi sapeva di 'scorciatoia')

Non capisco il problema .... il costruttore è pubblico, se passi i parametri corretti come quantità, tipi, non vedo problemi.

sì hai ragione, bastava gestire l'eccezione in effetti, in questo modo si informa correttamente l'utente che ha fatto qualcosa di sbagliato/non previsto

Una soluzione è usare un metodo di "factory", in Utente metti un metodo statico creaFounder che riceve i dati nome ecc... e ovviamente creaFounder deve poter creare 1 solo fondatore, quindi un campo static per il fondatore lo devi comunque tenere.

temo che non sia ammissibile in questo caso

Tenendo la tua architettura attuale, in Utente aggiungi anche la informazione di utentePresentato (non solo utentePresentante). Perché? Pensaci .... così puoi legare i due utenti presentato e presentatore.
Quando crei un nuovo utente passando un "presentatore" fai in modo che il utentePresentato di presentatore faccia riferimento al this del nuovo utente che stai creando. Così sono legati e se successivamente si tenta di creare un nuovo utente con quello stesso "presentatore", puoi verificare che il suo utentePresentato sia null o no.

era quello che stavo cominciando a pensare, grazie

[Jamie04]

Ho risolto il primo problema, adesso posso creare il fondatore fuori la classe Utente senza avere problemi. Ecco il codice (ho tralasciato le parti non interessanti):

public class Utente {
    //definisco le variabili istanza e di classe
    private String nome, cognome;
    private String nickname;
    private Date dataNascita;
    private Utente utentePresentante;
    public static int numFounder=0;
    
    //costruttore founder
    public Utente (String nome, String cognome, String nickname, Date dataNascita) {
        this.nome=nome;
        this.cognome=cognome;
        this.nickname=nickname;
        this.dataNascita=dataNascita;
        numFounder++;
        if (numFounder>1) {
            System.out.println("Stai cercando di creare piu' di un fondatore o un utente senza utente che lo presenta!!");
            System.exit(-1);
        }
    }
    
    //costruttore utente
    public Utente (String nome, String cognome, String nickname, Date dataNascita, Utente utentePresentante) {
        this.nome=nome;
        this.cognome=cognome;
        this.nickname=nickname;
        this.dataNascita=dataNascita;
        this.utentePresentante=utentePresentante;
    }

In questo modo se tento di creare più di un fondatore (o parimenti un utente senza presentante) il programma manda un messaggio di errore e si arresta.
Che cosa ne pensate di questa soluzione? Vi sembra adeguata?
Grazie.

[Jamie04]

Una soluzione è usare un metodo di "factory", in Utente metti un metodo statico creaFounder che riceve i dati nome ecc... e ovviamente creaFounder deve poter creare 1 solo fondatore, quindi un campo static per il fondatore lo devi comunque tenere.
Qui allora o cambi radicalmente la architettura, ovvero crei una entità (=classe) SocialNetwork che contiene tutte le informazioni e associazioni tra utenti necessarie (e Utente modella solo più nome+cognome+nickname+dataNascita e basta).
Oppure ...

Ciao, allora ho fatto vedere al prof la classe ma mi ha detto che nella classe utente ho gestito troppe cose (il problema del fondatore in pratica). Certo poteva scrivere il testo degli esercizi in maniera differente...perché i vincoli "un utente può entrare solo se presentato da un altro utente, un utente non può presentare più di un utente" erano stati definiti nell'esercizio mentre si parlava di modellare la classe Utente, per questo ho pensato che andassero gestiti là.
Cmq. In pratica dovrei cambiare l'architettura. Utente modella solo le informazioni sull'utente, e la classe SocialNetwork fa tutti i controlli...circa.
Ma se nel costruttore di Utente non inserisco utentePresentante, come li implemento questi legami nel socialnetwork? Perché mi si chiede di implementare un metodo per l'inserimento di un utente

Grazie!

[andbin]

In pratica dovrei cambiare l'architettura. Utente modella solo le informazioni sull'utente, e la classe SocialNetwork fa tutti i controlli...circa.

Ok, e così tra l'altro è anche "modellato" in modo più sensato e realistico.

Ma se nel costruttore di Utente non inserisco utentePresentante, come li implemento questi legami nel socialnetwork? Perché mi si chiede di implementare un metodo per l'inserimento di un utente

Allora è SocialNetwork che deve avere la/e struttura/e dati necessarie per mantenere tutte le associazioni e poter fare tutti i necessari controlli.

[Alex'87]

Parentesi, se un giorno avrai bisogno di manipolare date ti sconsiglio di usare le classi standard di Java e ti consiglio invece di usare JodaTime che ha una API decisamente migliore

[Jamie04]

Ok grazie lo terrò presente, ma in questo frangente era una cosa del tutto marginale.
Nel frattempo mi è venuta in mente un'altra versione e l'ho così strutturata, mi sembra migliore, e forse dico forse potrebbe aiutarmi a risolvere il problema del fondatore che non ha nessuno da presentare appena creato...

public class Utente2 {
    //definisco variabili istanza e di classe
    private String nome, cognome;
    private String nickname;
    private Date dataNascita;
    private Utente2 utentePresentante;
    public static int numFounder=0; //numero fondatori
    
    //costruttore fondatore
    public Utente2 (String nome, String cognome, String nickname, Date dataNascita) {
        this(nome, cognome, nickname, dataNascita, null);
        ++numFounder;
    }
    //costruttore utenti
    public Utente2 (String nome, String cognome, String nickname, Date dataNascita, Utente2 utentePresentante) {
        if (numFounder>1) {
            throw new IllegalArgumentException();
        } else {
        this.nome=nome;
        this.cognome=cognome;
        this.nickname=nickname;
        this.dataNascita=dataNascita;
        this.utentePresentante=utentePresentante;
        }
    }

[andbin]

    //costruttore founder
    public Utente (String nome, String cognome, String nickname, Date dataNascita) {
        this.nome=nome;
        this.cognome=cognome;
        this.nickname=nickname;
        this.dataNascita=dataNascita;
        numFounder++;
        if (numFounder>1) {
            System.out.println("Stai cercando di creare piu' di un fondatore o un utente senza utente che lo presenta!!");
            System.exit(-1);
        }
    }

Concettualmente questa mi pare l'unica alternativa al metodo statico di factory. Invece di usare un int potevi usare un boolean .... ma il succo è quello. Far uscire con System.exit mi pare un po' radicale ma se ti va bene così, per me è ok.