Un metodo "start", "run" o "execute" è una buona pratica?

Un metodo Start() (come Run() , Execute() o qualcosa di simile) è appropriato quando il costo della costruzione dell'oggetto è basso, ma il costo di usando è alto. Ad esempio: una classe che incapsula un algoritmo di ottimizzazione del percorso migliore. È banale impostarlo con un set di parametri ( X quadrati di Y quadrati, con il metodo di valutazione di suchandsuch), ma potrebbe richiedere del tempo per essere eseguito. Se vuoi creare 20 di questi oggetti, potresti voler ritardare l'esecuzione fino a quando non sono stati creati tutti - questo ti permette di parallelizzarli più facilmente, per esempio.

In alternativa, potrebbe essere utile quando non sai quando l'oggetto sarà necessario per iniziare, forse perché si basa sull'input dell'utente, o sulla logica che seleziona da un elenco di possibilità.

Ciò presuppone, ovviamente, che Start() sia il metodo utile sull'oggetto e non equivalente a un metodo Initialize() . Se è solo un modo extra per impostare più parametri, non dovrebbe esistere.

Codice completo (e molte altre risorse di ingegneria del software) sottolinea l'abbinamento delle tue classi agli oggetti del mondo reale. Credo che la ragione fondamentale per questo è che rende più probabile che tu abbia una vera comprensione di ciò che stai implementando, piuttosto che distruggere un'intangibile idea.

Se sei un sottoscrittore di questa teoria, non vedo nulla di sbagliato nell'aggiungere un metodo Start() a qualsiasi classe che dovrebbe, se fosse un oggetto reale, avere anche uno stato di riposo. Se non ha senso che il tuo oggetto esista mentre non è in esecuzione (o non ha senso che il tuo oggetto sia in esecuzione), allora direi che è una cattiva pratica.

Puoi usare inizializzazione pigra.

In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed.

In questo modo eviti l'accoppiamento temporale, il che significa che il consumatore della tua classe deve chiamare determinati metodi in un determinato ordine. Il chiamare prima start() è un modo per sapere come la classe funziona internamente, il che non va bene perché potresti cambiarlo in futuro.

Ritarda l'inizializzazione costosa fino a quando non è necessario.

Esempio:

public class FooClass{

    private ExpensiveResource resource;
    private CheapResource cheap;

    public  FooClass(String someParameter){
        // constructor: initialize CheapResource cheap 
            // but NOT ExpensiveResource resource
    }

    public ExpensiveResource getExpensiveResource(){
        if (resource == null) {
            this.initializeExpensiveResource();     
        }
        return this.resource
    }

    public String getExpensiveResourceName(){
        if (resource == null) {
            this.initializeExpensiveResource();     
        }
        return this.resource.getName();
    }   

    public CheapResource getCheapResource(){
        return this.cheap;
    }

    private initializeExpensiveResource(){
        // do expensive initialization of field "resource"
    }

}

public class Test{
    public static void main (String args[]){

        FooClass foo = new FooClass("some string");
        CheapResource cr = foo.getCheapResource();
        String s = foo.getExpensiveResourceName(); 
          // just now is the expensive resource initialized

    }
}