In quale ordine definire getter e setter? [chiuso]

Esiste una best practice per l'ordine in cui definire getter e setter? Sembra che ci siano due pratiche:

• coppie getter / setter
• prima getter, poi setter (o viceversa)

Per illuminare la differenza ecco un esempio Java di coppie getter / setter:

public class Foo {
    private int var1,
    var2,
    var3;

    public int getVar1() {
    return var1;
    }

    public void setVar1(int var1) {
    this.var1 = var1;
    }

    public int getVar2() {
    return var2;
    }

    public void setVar2(int var2) {
    this.var2 = var2;
    }

    public int getVar3() {
    return var3;
    }

    public void setVar3(int var3) {
    this.var3 = var3;
    }
}

Ed ecco un esempio Java dei primi getter, quindi dei setter:

public class Foo {
    private int var1,
    var2,
    var3;

    public int getVar1() {
    return var1;
    }

    public int getVar2() {
    return var2;
    }

    public int getVar3() {
    return var3;
    }

    public void setVar1(int var1) {
    this.var1 = var1;
    }

    public void setVar2(int var2) {
    this.var2 = var2;
    }

    public void setVar3(int var3) {
    this.var3 = var3;
    }
}

Penso che quest'ultimo tipo di ordinamento sia più chiaro sia nei diagrammi di codice che in quelli delle classi, ma non so se sia sufficiente per escludere l'altro tipo di ordinamento.

Il primo modo. Se possibile, raggruppa sempre o tieniti vicino alle funzioni correlate che operano sugli stessi membri.

Se disponi il tuo codice in questo modo, diventa più chiaro e più semplice il refactoring, poiché se una classe può essere fattorizzata da un'altra che sta facendo troppo, il pezzo fatturabile di solito ruota attorno a una specifica variabile membro.

In generale è più facile eseguire il debug, comprendere e manipolare il codice quando è possibile vedere tutti sulla stessa pagina l'intero ciclo di vita di un oggetto / variabile. Andrei fino al punto di dire che la disposizione del codice basata principalmente su superficialità come ambito e ordine alfabetico significherà in realtà perdere opportunità di refactoring perché non riesci a vederle.

Se fai parte di una squadra, fai quello che fanno di solito. Altrimenti scegli quello che ti piace di più. Sulla scala di importanti scelte progettuali questo è probabilmente da qualche parte vicino "quale pollice dovrei usare per colpire la barra spaziatrice?"

Può anche dipendere dalla lingua. In Java non c'è un reale vantaggio per entrambi gli ordini, ma in C #, ad esempio, hai il concetto di "proprietà", che raggruppa il getter e il setter insieme, quindi in qualche modo rafforza tale ordinamento. In un linguaggio come C ++, in cui potresti desiderare una visibilità diversa su getter rispetto a setter (ad esempio setter privato, getter pubblico), probabilmente faresti il ​​contrario, poiché il modificatore di visibilità viene dato una volta per più metodi, piuttosto che individualmente per ciascuno .

Per quanto ne so, non esiste una convenzione unica. La sezione Convenzioni del codice Java Oracle sull'organizzazione dei file non menziona esplicitamente il posizionamento di getter e setter, ma dice:

Questi metodi dovrebbero essere raggruppati per funzionalità piuttosto che per ambito o accessibilità.

Questo non fornisce alcuna guida: potrei sostenere che uno dei due posizionamenti soddisfa questi criteri.

Qualcosa da considerare è che gli IDE moderni ti consentono di avere viste più astratte della struttura dei tuoi file che come componente del codice testuale. Questo, unito a potenti strumenti di ricerca, dovrebbe facilitare la navigazione dei file e trovare i metodi appropriati anche all'interno di file di grandi dimensioni.

Ad esempio, Eclipse fornisce una vista Struttura che consente di ordinare e filtrare metodi e campi in diversi modi e di navigare fino a dove si trovano nei file. NetBeans aveva funzionalità simili e sospetto che lo siano anche la maggior parte degli altri IDE.

L'unica volta che questo può importare è se stai leggendo il codice al di fuori del tuo IDE. Un esempio potrebbe essere l'utilizzo di uno strumento di revisione del codice esterno o la visualizzazione di delta dal sistema di controllo della versione.

La soluzione migliore sarebbe quella di essere semplicemente coerenti tra i file in un progetto. Trova uno standard, documentalo e rispettalo.

Raggruppa getter e setter per un singolo campo insieme, in coppia.

Raggruppare tutti i getter e tutti i setter rende difficile dire quali campi hanno solo getter o solo setter.

Quando leggo il codice o cerco funzionalità specifiche, immagino che una classe abbia dei campi, con ogni campo che ha un getter e un setter. Non ha senso per una classe avere un gruppo getters e un gruppo setter, ognuno con campi.

Sempre Java IDE può generare getter e setter per te. Basta usare quella funzionalità e lasciare l'ordine di quei metodi come l'IDE l'ha creata. Questo è un codice generato, non toccarlo inutilmente.