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.

[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.

[Jamie04]

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.

No, così no. Puoi "legalmente" ottenere più utenti fondatori senza alcun avviso o errore.

Non mi pare, ho provato e non me lo fa fare.
Se creo due utenti senza presentante mi dà errore.

[andbin]

Non mi pare, ho provato e non me lo fa fare.
Se creo due utenti senza presentante mi dà errore.

Sì sì scusa, non ho controllato tutto bene io, oggi non sto molto bene. Infatti ho tolto il secondo pezzo.