Se modifico un campo privato usando un altro setter, è una cattiva pratica?

Question

Se modifico un campo privato usando un altro setter, è una cattiva pratica?

#1 da (3 voti)
#2 da (0 voti)

0

Ho una classe java in cui ho pochi booleani e un arraylist. Se il campo booleano è impostato su true, devo aggiungerlo all'arrayist. Uno dei modi in cui posso farlo è quello di usare i setter di ogni booleano per aggiungere elementi all'arrayist.

Ma è una buona pratica di programmazione? Non sono riuscito a trovare informazioni concrete su Google sullo stesso Per es.

public class Thisismyclass implements Serializable {
private boolean abc;
private boolean xyz;
private boolean pqr;
private ArrayList<String> stringList;

public ArrayList<String> getStringList() {
    if (stringList==null){
        return new ArrayList<>();
    }
    return stringList;
}

public void setStringList(ArrayList<String> stringList) {
    this.stringList = stringList;
}

public boolean isAbc() {
    return abc;
}

public void setAbc(boolean abc) {
    this.abc = abc;
    this.getStringList().add("abc");
} }

design java

posta phoenixSid 26.07.2018 - 14:27

fonte

2 risposte

Leggi altre domande sui tag design java

Un modo elegante per rilevare la fine di una ricerca di file ricorsiva asincrona? Can Root Factory di aggregazione può creare la radice e le sue classi interne?

score 3 · Answer 1

L'esempio che hai fornito sarebbe probabilmente considerato una cattiva pratica, ma un esempio più comune sarebbe mantenere un flag dirty . Il flag dirty consente al layer di persistenza di sapere che ci sono modifiche in sospeso da salvare. (Se si utilizzano gli strumenti ORM, questa logica viene gestita nel codice generato da tale strumento). Esempio:

public class MyThing {
    private boolean changed = false;
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String newValue) {
        value = newValue;
        changed = true;
    }

    public boolean isChanged() {
        return changed;
    }
}

Questo schema è dove hai uno stato aggiuntivo che non è completamente esposto al codice usando la classe. Il livello di persistenza salterà allegramente cercando di mantenere il record se già esiste e non è cambiato.

Detto questo, fornire un meccanismo per cambiare il valore del campo changed dall'esterno della classe sarebbe sicuramente un antipattern, perché non puoi più garantire che changed corrisponda alla condizione effettiva dell'oggetto.

score 0 · Answer 2

Non c'è nulla di intrinsecamente sbagliato nel modificare più di una variabile privata nel setter. I nomi delle variabili nel tuo esempio non hanno alcun significato o contesto utile, quindi posso solo indovinare di cosa si tratta. Sulla base del fatto che stai aggiungendo il nome della proprietà ("abc") alla "lista di stringhe", immagino che questa sia una sorta di implementazione di pattern osservabili. Niente di male in questo, di per sé.

C'è un grosso problema con questa classe, comunque. È che hai un getter e setter per una lista. Questo è un approccio terribile e terribile. Una parte del codice può chiamare il getter per la lista ed essere in grado di vedere tutte le stringhe "abc" che si aggiungono ad essa e iniziare ad aggiungere i propri valori come "butt" e "poop" (o qualsiasi oggetto in realtà) ma solo fino a quando un'altra parte del programma sostituisce l'oggetto lista che il tuo oggetto utilizza internamente con il proprio elenco. Questa è una rottura tremendamente eclatante di incapsulamento. Sarà sicuramente un incubo di debug. Ho detto che questo è un approccio terribile?

Non si dovrebbe mai mai restituire o accettare una raccolta o un array in un setter. Anche restituire una raccolta o un array modificabili da un getter è un grosso errore. Se darai un po 'più di contesto a quello che stai cercando di realizzare, offrirò alcuni approcci alternativi.

Ecco un piccolo codice per dimostrare come si comporta il codice corrente. Ho aggiunto una stampa a setAbc che conta le chiamate per aiutare a rendere più chiaro cosa sta succedendo:

final Thisismyclass instance = new Thisismyclass();

ArrayList<String> listA = instance.getStringList();
ArrayList<String> listB = instance.getStringList();

System.out.println();
System.out.println("listA: " + listA);
System.out.println("listB: " + listB);

instance.setStringList(listB);

ArrayList<String> listC = instance.getStringList();

System.out.println();
System.out.println("listA is same as listB? " + (listA == listB));
System.out.println("listB is same as listC? " + (listB == listC));

listB.add("yipee!");
instance.setAbc(true);

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 

instance.setStringList(null); // HA HA!

instance.setAbc(true);

ArrayList<String> listD = instance.getStringList();

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 

System.out.println();
System.out.println("listD is same as listA? " + (listD == listA)); 
System.out.println("listD is same as listB? " + (listD == listB)); 
System.out.println("listD is same as listC? " + (listD == listC)); 

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 

instance.setAbc(true);

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 

ArrayList<String> listE = instance.getStringList();
ArrayList<String> listF = instance.getStringList();

listE.add("nananananananananana Batman!");

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 
System.out.println("listE: " + listE); 
System.out.println("listF: " + listF); 

instance.setAbc(true);

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 
System.out.println("listE: " + listE); 
System.out.println("listF: " + listF); 

instance.setStringList(listE);

ArrayList<String> listG = instance.getStringList();

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 
System.out.println("listE: " + listE);
System.out.println("listF: " + listF); 
System.out.println("listG: " + listG);

instance.setAbc(true);

System.out.println();
System.out.println("listA: " + listA); 
System.out.println("listB: " + listB); 
System.out.println("listC: " + listC); 
System.out.println("listD: " + listD); 
System.out.println("listE: " + listE); 
System.out.println("listF: " + listF); 
System.out.println("listG: " + listG);