Override metodi setter e getter

[Gas75]

Ho modificato...
In sostanza nel costruttore di Camicia passo ogni parametro al costruttore di Abbgliamento tramite super(), seguito da this.stile = stile; specifico dell'oggetto Camicia. Non faccio altro in quel blocco di codice.
Poi sovrascrivo setColore(): in questo modo ho passato (col costruttore) codiceColore alla superclasse e lo tengo, diciamo, in standby, ora lo verifico e, nel caso, intervengo lanciando una Exception con un getMessage().
Ho fatto girare il mio programma con queste impostazioni e funziona. Pare quindi che il controllo sul costruttore non sia necessario, e che l'importante sia esclusivamente l'override del setter.

Ti torna come ragionamento?

[andbin]

Pare quindi che il controllo sul costruttore non sia necessario, e che l'importante sia esclusivamente l'override del setter.

Lo ripeto ancora .... se nella sottoclasse vuoi imporre una "restrizione" sul valore di un campo e questo valore è fornito alla sottoclasse tramite costruttore E setter, allora la restrizione concettualmente (poi come la realizzi tecnicamente è un altro discorso) va applicata in ENTRAMBI i punti.

[Gas75]

Non discuto le tue competenze, ma da varie prove (anche con valori non corretti e usando il riferimento alla superclasse creando l'istanza), ho riscontrato che l'override di setColore() viene ignorato , il che è molto strano dato che l'override dell'altro metodo, display(), viene eseguito in tutti i casi.

[andbin]

ho riscontrato che l'override di setColore() viene ignorato

Riposta qui le due classi, che vediamo ....

[Gas75]

L'unica classe modificata è Camicia.java; questa è la versione dove setColore() dovrebbe accedere a super.setColore() se il valore di codiceColore non è corretto.

public class Camicia extends Abbigliamento {
    private char stile = 'U';
    public Camicia(int elementoID, String descrizione, char codiceColore, double prezzo, char stile) {
        super(elementoID, descrizione, codiceColore, prezzo);
        this.stile = stile;
    }
    public char getStile() {
        return stile;
    }
    public void setStile(char stile) {
        this.stile = stile;
    }
    // Sovrascrivo setColore() della superclasse
    public void setColore(char codiceColore) {
        switch(codiceColore) {
            case 'B':
            case 'G':
            case 'R':
            case 'U':
                break;
            default:
                super.setColore('X');
        }
    }
    
    // Sovrascrivo display() della superclasse
    public void display() {
        System.out.println("Camicia ID: " + getElementoID());
        System.out.println("Camicia descrizione: " + getDescrizione());
        System.out.println("Camicia prezzo: " + getPrezzo());
        System.out.println("Codice colore: " + getColore());
        System.out.println("Stile: " + getStile());
    }
}

Manca volutamente lo switch nel costruttore, perché volevo verificare l'override, e come potrai verificare usando un char non incluso nei case, lo fa su display() ma non su setColore().
Insomma a controllare è solo lo switch del costruttore, quando c'è.

[andbin]

dovrebbe accedere a super.setColore() se il valore di codiceColore non è corretto.

E se il codice è corretto?? Non fai nulla? Ma che senso ha???

Scusa eh ....

[Gas75]

Così?

	public void setColore(char codiceColore) {
		switch(codiceColore) {
			case 'B':
			case 'G':
			case 'R':
			case 'U':
				super.setColore(codiceColore);
				break;
			default:
				super.setColore('X');
		}
	}

Operativamente non cambia nulla: se il codiceColore è corretto lo stampa, se non lo è... lo stampa ugualmente; il default non viene mai considerato, quindi devo presumere che l'override non sia stranamente eseguito per setColore().

[andbin]

Operativamente non cambia nulla: se il codiceColore è corretto lo stampa, se non lo è... lo stampa ugualmente; il default non viene mai considerato, quindi devo presumere che l'override non sia stranamente eseguito per setColore().

Ascolta: ho preso la classe Abbigliamento che hai postato all'inizio nel post #1, poi ho preso la classe Camicia che hai postato nel post #25 con l'unica aggiunta (che poi hai fatto) di mettere super.setColore(codiceColore); prima del break.
Non ho cambiato null'altro.

Poi ho scritto un piccolo main di prova:

public class Prova {
    public static void main(String[] args) {
        Abbigliamento a = new Camicia(123, "Camicia", 'z', 39.9, 'S');
        a.display();
        System.out.println("--------------");
        a.setColore('G');    // G è valido per setColore di Camicia
        a.display();
        System.out.println("--------------");
        a.setColore('y');    // y non è valido per setColore di Camicia
        a.display();
    }
}

L'output è:

Camicia ID: 123
Camicia descrizione: Camicia
Camicia prezzo: 39.9
Codice colore: z
Stile: S
--------------
Camicia ID: 123
Camicia descrizione: Camicia
Camicia prezzo: 39.9
Codice colore: G
Stile: S
--------------
Camicia ID: 123
Camicia descrizione: Camicia
Camicia prezzo: 39.9
Codice colore: X
Stile: S

L'output dimostra che:
1) Il display() è quello di Camicia (c'è lo Stile infatti)
2) Il costruttore di Camicia NON applica restrizioni sul codiceColore (accetta 'z'). Ma questo lo sapevamo già e te l'ho detto. Dovrai provvedere tu.
3) Il primo setColore('G') (secondo display visualizzato) è accettato.
4) Il secondo setColore('y') (terzo display visualizzato) NON è accettato e infatti passa nel default ed imposta 'X'.

(nota: la variabile 'a' può essere Abbigliamento o Camicia ... NON fa differenza)

Quindi ...... di QUALI problemi/dubbi stiamo parlando??

[Gas75]

Forse sono arrivato a una soluzione, in sostanza ho rimosso i costruttori espliciti.
Superclasse aggiornata:

public class Abbigliamento {
    // Campi
    private int elementoID = 0;
    private String descrizione = "-descrizione richiesta-";
    private char codiceColore = 'U';
    private double prezzo = 0.0;
    
    // getter
    public String getDescrizione() {
        return descrizione;
    }
    public double getPrezzo() {
        return prezzo;
    }
    public int getElementoID() {
        return elementoID;
    }
    public char getCodiceColore() {
        return codiceColore;
    }
    // setter
    public void setElementoID(int elementoID) {
        this.elementoID = elementoID;
    }
    public void setDescrizione(String descrizione) {
        this.descrizione = descrizione;
    }
    public void setCodiceColore(char codiceColore) {
        this.codiceColore = codiceColore;
    }
    public void setPrezzo(double prezzo) {
        this.prezzo = prezzo;
    }
    
    public void display() {
        System.out.println("ID elemento: " + getElementoID());
        System.out.println("Descrizione: " + getDescrizione());
        System.out.println("Prezzo: " + getPrezzo());
        System.out.println("Codice colore: " + getCodiceColore());
    }
}

Sottoclasse aggiornata:

public class Camicia extends Abbigliamento {
    private char stile = 'U';
    // getter
    public char getStile() {
        return stile;
    }
    // setter
    public void setStile(char stile) {
        this.stile = stile;
    }
    public void setCodiceColore(char codiceColore) {
        switch(codiceColore) {
            case 'B':
            case 'G':
            case 'R':
            case 'U':
                super.setCodiceColore(codiceColore);
                break;
            default:
                super.setCodiceColore('X');
        }
    }
    // Sovrascrivo display() della superclasse
    public void display() {
        System.out.println("Camicia ID: " + getElementoID());
        System.out.println("Camicia descrizione: " + getDescrizione());
        System.out.println("Camicia prezzo: " + getPrezzo());
        System.out.println("Codice colore: " + getCodiceColore());
        System.out.println("Stile: " + getStile());
    }
}

Classe Test:

public class LaCamicia {
    public static void main(String args[]) {
        Camicia LaCamicia = new Camicia();
        LaCamicia.setElementoID(123);
        LaCamicia.setDescrizione("Camicia elegante");
        LaCamicia.setCodiceColore('R'); // valore valido
        LaCamicia.setPrezzo(33.99);
        LaCamicia.setStile('S');
        LaCamicia.display();
        System.out.println("---------------");
        LaCamicia.setCodiceColore('Y'); // valore errato
        LaCamicia.display();
    }
}

L'output è il seguente:

Camicia ID: 123
Camicia descrizione: Camicia elegante
Camicia prezzo: 33.99
Codice colore: R
Stile: S
---------------
Camicia ID: 123
Camicia descrizione: Camicia elegante
Camicia prezzo: 33.99
Codice colore: X
Stile: S

Ho detto "forse" perché, passando un valore a setStile(), non posso istanziare con riferimento ad Abbigliamento. Stando alla "teoria", sarebbe pure logico che fosse così: se istanzio come superclasse voglio usare i metodi della superclasse...

Fammi sapere per favore se è finalmente corretto o se persiste qualche sbavatura che mi è sfuggita.

[andbin]

ho rimosso i costruttori espliciti.

Se togli i costruttori, tutto va settato esplicitamente tramite dei setter. E ovviamente avere la restrizione solo nel setCodiceColore è chiaramente una semplificazione, che va anche bene.

Si potevano tenere i costruttori e mettere la restrizione in 1 solo punto in Camicia .... ma forse non ci sei arrivato ....

passando un valore a setStile(), non posso istanziare con riferimento ad Abbigliamento.

Ovviamente. Ma nel punto dove istanzi Camicia nessuno ti vieta di avere la variabile come Camicia. E poi assegnarla ad un Abbigliamento, SE/dove necessario per sfruttare il polimorfismo.