Best practice per la definizione di una variabile Java che agisce (qualcosa) come una variabile statica locale di C

Question

In C, posso creare una variabile statica in una funzione. Lo spazio per quella variabile non è allocato insieme alle variabili di funzione, è allocato al momento dell'avvio del programma. (Non prendere in giro il mio C troppo duramente, Sono stato di programmazione in Java per troppo tempo :)

void myFunc(){ 
    static SomeStruct someStruct; 
    someStruct.state=INITIALIZED; 
    goDoSomethingInteresting(MY_COMMAND,&someStruct); 
} 

In Java, se voglio fare qualcosa di simile, creo una variabile di classe e poi usarlo .

Class TheClass { 
    SomeStruct someStruct = new SomeStruct(); 
    void myFunc(){ 
    someStruct.setState(INITIALIZED); 
    goDoSomethingInteresting(MY_COMMAND,someStruct); 
    } 
} 

La mia domanda è qual è la migliore pratica per fare qualcosa del genere? Mi piacerebbe davvero associare la mia variabile someStruct con la mia funzione myFunc, perché someStruct è l'unico codice che dovrebbe conoscere o usare someStruct, ma non c'è modo di farlo, se non per mettere la variabile vicino alla funzione nel codice. Se lo metti sopra, allora il Javadoc per la funzione sembra stordito, se lo metti sotto, quindi non è molto chiaro che essi appartengono insieme.

Normalmente vorrei solo creare someStruct a livello locale, ma nel mio caso è molto costoso per creare someStruct, e io chiamare myFunc in un loop stretto.

Answer 1

Una piccola classe associerà someStruct con il comportamento di myFunc in modo pulito, ma è un overhead aggiuntivo per la comprensione e il mantenimento delle cose. Potrebbe valere la pena, potrebbe non esserlo.

class TheClass { 
    MyFuncBehavior myFuncer = new MyFuncBehavior(); 
    void myFunc() { 
     myFuncer.myFunc(); 
    } 
} 

class MyFuncBehavior { 
    private static SomeStruct someStruct = new SomeStruct(); 

    public void myFunc() { 
    someStruct.setState(INITIALIZED); 
    goDoSomethingInteresting(MY_COMMAND,someStruct); 
    } 
} 

Answer 2

Non penso che ci sia molto da fare cercando di forzare l'incapsulamento all'interno di un singolo file sorgente (cioè una classe e tutte le sue classi interne) e Java sembra seguire questo principio.

Chiunque abbia accesso al codice sorgente può cambiarlo per avere accesso a qualsiasi campo.

Tuttavia ridisegnare il codice è un'opzione:

1. È possibile estrarre myFunc() in una classe separata con il campo che utilizza.
2. È possibile modificare semplicemente la firma del metodo su void myFunc(SomeStruct struct) e passarlo come parametro. Memorizzarlo come variabile locale del chiamante.

Se il ciclo è davvero molto stretto, il sovraccarico sarà minimo. (Personalmente non farei nessuno dei precedenti.)

Answer 3

In Java, se voglio fare qualcosa di simile, creo una variabile di classe e poi la uso.

Sì, è la migliore pratica.

Answer 4

Dato che si sta scrivendo la classe java, è sufficiente renderlo un membro privato della classe. Metti un commento accanto ad esso se vuoi impedire ad altre persone che potrebbero lavorare su quello stesso file di utilizzarlo altrove nel file.

Answer 5

In C una function static variable

• ha la durata del programma
• ha lo scopo della funzione

Cioè, una volta inizializzato cui dispone in ciascuna chiamata a la funzione con l'ultimo valore assegnato ad essa ma non accessibile al di fuori della funzione.

Questo si adatta bene se si converte la funzione in una classe con un metodo e si rende la variabile statica un membro di quella classe.

ad es.

void F() 
{ 
    static int i; 
} 

Diventa

class F 
{ 
    int i; 
    func() .... 
}