La ridenominazione di un metodo può preservare l'incapsulamento?

Stavo leggendo questa pagina , su quando giustificativi / setter sono giustificati e l'OP ha fornito il seguente esempio di codice:

class Fridge
{
     int cheese;

     void set_cheese(int _cheese) { cheese = _cheese; }
     int get_cheese() { return cheese; }
 }

void go_shopping(Fridge fridge)
{
     fridge.set_cheese(fridge.get_cheese() + 5);        
}

La risposta accettata afferma:

A proposito, nel tuo esempio, darei alla classe Fridgei metodi putCheese()e takeCheese(), invece di get_cheese() e set_cheese(). Quindi avresti ancora l'incapsulamento.

Come viene conservato l'incapsulamento rinominandolo da get / set in putCheese()/ takeCheese()Stai ovviamente ottenendo / impostando un valore, quindi perché non lasciarlo semplicemente come get / set?

Nella stessa risposta si afferma anche:

Avere getter e setter non rompe di per sé l'incapsulamento. Ciò che interrompe l'incapsulamento è l'aggiunta automatica di un getter e un setter per ogni membro di dati (ogni campo, in java lingo), senza pensarci.

In questo caso, abbiamo solo una variabile, cheesee potresti voler prendere e restituire il formaggio in frigorifero, quindi una coppia get / set in questo caso è giustificata.

Penso che tu non abbia capito. Non sta dicendo che dovresti rinominare setter e getter, ma avere metodi che aggiungono e rimuovono oggetti dal frigorifero. vale a dire

public class Fridge
{
    private int numberOfCheeseSlices;

    public void AddCheeseSlices(int n)
    {
         if(n < 0) { 
             throw new Exception("you cant add negative cheese!");
         }
         if(numberOfCheeseSlices + n > this.capacityOfFridge) { 
             throw new Exception("TOO MUCH CHEESE!!");
         }
         ..etc
         this.numberOfCheeseSlices += n;
    }
}

Ora la variabile privata è incapsulata. Non posso limitarlo a tutto ciò che voglio, posso solo aggiungere e rimuovere fette di formaggio dal frigorifero usando i metodi, che a loro volta assicurano che vengano applicate tutte le regole di logica aziendale del formaggio che voglio.

Getter e setter rompono l'incapsulamento ogni volta , per definizione. Ciò che potrebbe essere discusso è che a volte dobbiamo farlo. A parte questo, ecco le mie risposte:

Come si conserva l'incapsulamento rinominandolo da get / set in putCheese () / takeCheese () Ovviamente stai ottenendo / impostando un valore, quindi perché non lasciarlo semplicemente come get / set?

La differenza sta nella semantica, ovvero nel significato di ciò che scrivi. L'incapsulamento non riguarda solo la protezione, ma nasconde lo stato interno. Lo stato interno non dovrebbe nemmeno essere conosciuto al di fuori, invece si prevede che l'oggetto offra metodi rilevanti per il business (a volte definiti "comportamento") per manipolare / utilizzare tale stato.

Quindi, gete setsono i termini tecnici e sembrano avere nulla a che fare con il dominio "frigo", mentre pute takepotrebbe effettivamente avere un senso.

Tuttavia , se puto takerendere effettivo senso dipende ancora i requisiti e non può essere oggettivamente giudicata. Vedi il prossimo punto:

In questo caso, abbiamo solo una variabile, il formaggio, e potresti voler prendere e riportare il formaggio in frigorifero, quindi una coppia get / set in questo caso è giustificata.

Ciò non può essere oggettivamente determinato senza più contesto. Il tuo esempio contiene un go_shopping()metodo altrove. Se questo è ciò che Fridgeserve, di ciò che non ha bisogno geto set, ciò di cui ha bisogno è Fridge.go_shopping(). In questo modo hai un metodo derivato dai requisiti, tutti i "dati" di cui ha bisogno sono locali e hai un comportamento reale invece di una struttura di dati sottilmente velata.

Ricorda, non stai costruendo un generico, riutilizzabile Fridge. Stai creando un solo Fridgeper le tue esigenze. Ogni sforzo speso per renderlo più di quello che deve essere è in realtà uno spreco.

Quasi tutto ciò mostra un fraintendimento fondamentale dell'incapsulamento e di come si applica.

La risposta iniziale che stavi interrompendo l'incapsulamento è semplicemente sbagliata. La tua applicazione potrebbe aver bisogno di impostare semplicemente il valore del formaggio nel frigorifero invece di incrementare / decrementare o aggiungere / rimuovere. Inoltre, non si tratta di semantica, indipendentemente da come la chiami, se hai bisogno di accedere e / o modificare attributi non rompi l'incapsulamento fornendoli. Infine, l'incapsulamento non riguarda in realtà il "nascondersi", si tratta di controllare l'accesso allo stato e ai valori che non dovrebbero essere pubblici o manipolati al di fuori della classe, concedendoli a quelli che dovrebbero ed eseguendo l'attività resa disponibile internamente.

Un getter o setter non rompe l'incapsulamento quando vi è una legittima necessità di ottenere o impostare un valore. Ecco perché i metodi possono essere resi pubblici.

L'incapsulamento riguarda il mantenimento dei dati e dei metodi che modificano i dati direttamente insieme in un posto logico, la classe.

In questo caso particolare, è chiaramente necessario modificare il valore del formaggio nell'applicazione. Indipendentemente da come ciò avviene, tramite get / set o aggiungi / remove, purché i metodi siano incapsulati nella classe, segui lo stile orientato agli oggetti.

Per chiarimenti, fornirò un esempio di come l'incapsulamento viene interrotto fornendo l'accesso indipendentemente dal nome del metodo o dall'esecuzione logica.

Supponiamo che il tuo frigorifero abbia una "durata", solo un numero di tick prima che il frigorifero non sia più operativo (per ragioni di discussione, il frigorifero non può essere riparato). Logicamente non è possibile che un utente (o il resto dell'applicazione) sia in grado di modificare questo valore. Dovrebbe essere privato. Sarebbe visibile solo attraverso un diverso attributo pubblico noto come "isWorking". Allo scadere della vita, internamente il set di frigoriferi sta funzionando su falso.

L'esecuzione del conto alla rovescia della durata e il suo lancio dell'interruttore isWorking è tutto interno al frigorifero, nulla al di fuori potrebbe / dovrebbe essere in grado di effettuare il processo. isWorking dovrebbe essere visibile, quindi un getter non rompe l'incapsulamento. Tuttavia l'aggiunta di accessori per gli elementi del processo di durata interromperebbe l'incapsulamento.

Come la maggior parte delle cose, la definizione di incapsulamento non è letterale, è relativa. Dovresti essere in grado di vedere X al di fuori della classe? Dovresti essere in grado di cambiare Y? Tutto ciò che si applica al tuo oggetto qui in questa classe o la funzionalità è distribuita su più classi?

Non è solo rinominare un metodo. I due metodi funzionano in modo diverso.

(Immagina questo nella tua mente)

get_cheese e set_cheese espongono il formaggio. putCheese () e takeCheese () mantiene nascosto il formaggio e si occupa della sua gestione e offre all'utente un modo per gestirlo. L'osservatore non vede il formaggio, vede solo due metodi per manipolarlo.