Come scrivere main () in un modo OOP?

StackOverflow https://stackoverflow.com/questions/325453

  •  11-07-2019
  •  | 
  •  

Domanda

Quando ho iniziato a programmare, ho scritto tutto principalmente. Ma, come ho appreso, ho cercato di fare il meno possibile nei miei metodi main () .

Ma dove decidi di assegnare all'altra Classe / Metodo la responsabilità di assumere il programma da main () ? Come lo fai?

Ho visto molti modi per farlo, in questo modo: 

class Main
{
  public static void main(String[] args)
  {
    new Main();
  }
}

e alcuni come: 

class Main {

   public static void main(String[] args) {

    GetOpt.parse(args);

    // Decide what to do based on the arguments passed
    Database.initialize();
    MyAwesomeLogicManager.initialize();
    // And main waits for all others to end or shutdown signal to kill all threads.
  }
}

Cosa dovrebbe e non dovrebbe essere fatto in main () ? O non ci sono proiettili d'argento?

Grazie per il tempo!

È stato utile?

Soluzione

Secondo me, il "principale" di un progetto considerevole dovrebbe contenere circa 3 chiamate di funzione:

  • Chiamare una funzione di inizializzazione che configura tutte le impostazioni, le preferenze, ecc. richieste per l'applicazione.
  • Avvio del "controller" principale " dell'applicazione
  • In attesa del termine del controller principale, quindi chiamando una funzione di terminazione che pulisce tutto ciò che deve essere ripulito in "main" (sebbene il controller si sia già occupato della maggior parte della pulizia).

Qualsiasi applicazione considerevole sarà divisa in blocchi di funzionalità, di solito con una certa gerarchia. Il controller principale può avere diversi controller figlio per funzioni specifiche.

Farlo in questo modo rende molto più facile individuare funzionalità specifiche e la separazione delle preoccupazioni è migliore.

Naturalmente, come hanno già detto altre risposte, non c'è davvero nessun proiettile d'argento nello sviluppo del software. Per un breve progetto potrei mettere tutto in primo piano solo per far funzionare le cose rapidamente. Penso che dipenda anche dalla lingua: alcune opzioni potrebbero essere più facili di altre in determinate lingue.

Altri suggerimenti

Codice nella funzione principale:

  • Non può essere testato in unità.
  • Impossibile ricevere dipendenze per iniezione.
  • Non può essere riutilizzato da altre applicazioni simili alla prima che scrivi.

Pertanto codice nella funzione principale:

  • Deve essere così semplice da soddisfare solo i test funzionali / di sistema.
  • Deve essere responsabile dell'impostazione del lancio della palla per le dipendenze utilizzate da tutti gli altri codici (vale a dire, le azioni principali sono come una super fabbrica che crea la tua applicazione).
  • Dovrebbe fare solo cose che sono particolari per il modo in cui è configurata la tua app (cioè non tutto ciò che il codice di test o la versione demo dovrà fare esattamente allo stesso modo).

In pratica, ciò significa che le app reali non hanno molto in generale. Le app per i giocattoli e i programmi one-shot potrebbero avere molto in linea di principio, perché non hai intenzione di testarli o riutilizzarli comunque.

In realtà, alcune delle cose che dico sopra sono specifiche del C ++. I principali metodi Java ovviamente possono essere chiamati tramite codice di test o app varianti. Ma non prendono ancora gli oggetti come parametri, ma solo argomenti da riga di comando, quindi la misura in cui possono essere isolati durante il test o comportarsi bene in termini di riutilizzo, è piuttosto bassa. Immagino che potresti passare i nomi delle classi affinché possano istanziare e utilizzare per creare il resto dell'app.

[Modifica: qualcuno ha rimosso " C ++, Java " tag da questa domanda. Quindi: quello che dico sopra è specifico per C ++ e Java. Altre lingue possono trattare il main in un modo meno speciale, nel qual caso potrebbe non esserci alcun motivo particolare per trattarlo in modo speciale.]

Qualunque cosa fa galleggiare la tua barca, come si suol dire. :) Dovresti davvero concentrarti sul rendere il codice semplice, facile da leggere ed efficiente, utilizzando tutti gli strumenti necessari per raggiungere questo obiettivo. Se merita di mettere un sacco di codice in main - fallo. Se ritieni che gli oggetti renderebbero le cose più organizzate, vai in questo modo.

Creare una singola istanza della classe Main e quindi chiamare il metodo dell'istanza Main () che fa tutto il lavoro è buono come scrivere tutto direttamente nel metodo principale .

Direi che non è ciò che è nella tua funzione principale, ma cosa non lo è. A seconda della complessità del tuo progetto, ti consigliamo di suddividerlo in sezioni funzionali, come "Funzioni database", "Funzioni di visualizzazione", "High Tea con il vicario", ecc.

È tutto sulla leggibilità del codice. Qualcun altro, che non ha mai visto il tuo programma prima di incontrarlo, e ottenere inizialmente una buona idea generalizzata di ciò che fa?

È quindi possibile vedere facilmente dove andare per scavare un po 'più a fondo nel meccanismo?

Ogni sezione funzionale che usi fa solo un blocco logico di processi? Non deve fare solo una cosa, ma non dovrebbe fare tutto più il lavello della cucina.

Suddividi il codice in modo che sia gestibile da una fonte esterna.

Causa cieli lo sa, quando si tratta proprio di esso, se qualcuno -else- può risolvere il bug, è tutto meglio =)

Come risposta diretta alla tua domanda, metterei le chiamate di funzione a ciascuno dei componenti principali in principale, l'installazione, il processo e la finitura, in modo che chiunque lo guardi ottenga una rapida panoramica di come il programma lavori. Possono quindi approfondire ulteriormente se necessario.

Guarda, il contenuto e la forma del "principale" il metodo dipende molto dal linguaggio e dall'ambiente. In Java, ogni classe può avere un metodo public static void main () , quindi è del tutto possibile averne più di uno.

Ma ora, pensiamo a questo tramite la legge di modularizzazione di Parnas: "ogni modulo nasconde un segreto, e quel segreto è qualcosa che può cambiare." Il "segreto" del modulo chiamato inizialmente sono i dettagli dell'interfaccia del processo con il sistema operativo: cose come ottenere gli argomenti e gestire le terminazioni irregolari. In Python, questo porta a qualcosa del genere: 

def main(args=None):
    #argument processing
    #construct instances of your top level objects
    #do stuff

if __name__ == "__main__":
   try:
      main(Sys.Argv)
   except: # everything
      # clean up as much as you can
   else:
      # normal cleanup, no exceptions

Il punto qui è che ottieni tutto dall'ambiente che puoi, quindi chiama la funzione main (); cogli tutte le eccezioni non rilevate e fai qualcosa di intelligente con loro prima che il programma muoia.

Penso che il metodo principale dovrebbe spiegare cosa fa il programma all'avvio. Quindi potrebbe chiamare metodi di inizializzazione, ma la logica dovrebbe essere estratta in metodi.

Nel tuo esempio, non vorrei creare un metodo Main (), ma inserirlo in quello originale.

Il design del tuo programma deciderà la forma del tuo " main " ;.

Avere una " regola " che dice come dovrebbe essere la tua funzione principale, è - IMHO - un non-senso.

Ricorda che se qualcuno vuole avere un'idea di come funziona il tuo programma, il primo posto che probabilmente vedrà è quello principale (almeno lo farei). Quindi, non penso sia una buona idea metterci il meno possibile. Ma direi di mettere il minimo necessario per avere una visione d'insieme di come funziona il tuo programma.

Quindi, penso che la tua più grande preoccupazione nell'implementazione di una funzione principale dovrebbe essere la leggibilità.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top