Come contrassegnare le sezioni logiche di codice nei commenti Java?

Le classi Java sono generalmente suddivise in "blocchi" logici. Esiste una convenzione per contrassegnare queste sezioni? Idealmente, sarebbe supportato dai principali IDE.

Personalmente utilizzo questo metodo:

//// Section name here ////

Tuttavia, alcuni editor sembrano avere problemi con questo.

Ad esempio, nel codice Objective-C puoi usare questo metodo:

#pragma mark -
#pragma mark Section name here

Ciò si tradurrà in un menu in XCode simile a questo:

Personalmente uso separatori di riga di 80 caratteri, in questo modo:

public class Client {

    //================================================================================
    // Properties
    //================================================================================

    private String name;
    private boolean checked;

    //================================================================================
    // Constructors
    //================================================================================

    public Client() {
    }

    public Client(String name, boolean checked) {
        this.name = name;
        this.checked = checked;
    }

    //================================================================================
    // Accessors
    //================================================================================

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isChecked() {
        return checked;
    }

    public void setChecked(boolean checked) {
        this.checked = checked;
    }

}

Naturalmente, questo può sembrare un po 'eccessivo per un POJO così piccolo, ma credetemi, si è rivelato molto utile in alcuni progetti enormi in cui ho dovuto sfogliare file sorgente di grandi dimensioni e trovare rapidamente i metodi che mi interessavano. Aiuta anche a capire la struttura del codice sorgente.

In Eclipse, ho creato una serie di modelli personalizzati (Java -> Editor -> Modelli nella finestra di dialogo Preferenze di Eclipse) che generano quelle barre, ad es. - sepa (SEParator for Accessors) - sepp (SEParator for Properties) - sepc (SEParator for Constructors) - ecc.

Ho anche modificato il modello standard "nuova classe" (Java -> Stile codice -> Modelli codice nella schermata Preferenze di Eclipse)

Inoltre, esiste un vecchio plugin Eclipse chiamato Coffee-bytes , che ha migliorato il modo in cui Eclipse piega parti di codice. Non so se funziona ancora, ma mi sono ricordato che si potrebbero definire zone pieghevoli arbitrarie aggiungendo commenti speciali, come // [SECTION] o qualcosa del genere. Potrebbe ancora funzionare nelle recenti revisioni di Eclipse, quindi dai un'occhiata.

Per intellij / android studio esiste una soluzione straordinaria.
Inizia con:
//region Description
e termina con:
//endregion

La scorciatoia per questo è nel menu che puoi aprire con Command+ Alt+ T(Mac) o Ctrl+ Alt+ T(Windows)

Puoi anche aggiungere la tua linea per un'ulteriore separazione visiva se ne hai bisogno. La regione può essere contratta ed espansa a piacimento con i pulsanti +/- come qualsiasi funzione. Puoi anche navigare tra le regioni con Command+ Alt+ Period( Ctrl+ Alt+ Period)

Fonte .

Esempio:

//region Parceler Implementation
//---------------------------------------------------------------------------------------
@Override
public int describeContents() {
    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
    dest.writeParcelable(this.die, 0);
    dest.writeParcelable(this.dieSprite, 0);
}

private DieVm(Parcel in) {
    this.die = in.readParcelable(Die.class.getClassLoader());
    this.dieSprite = in.readParcelable(Sprite.class.getClassLoader());
}

public static final Parcelable.Creator<DieVm> CREATOR = new Parcelable.Creator<DieVm>() {
    public DieVm createFromParcel(Parcel source) {
        return new DieVm(source);
    }

    public DieVm[] newArray(int size) {
        return new DieVm[size];
    }
};
//---------------------------------------------------------------------------------------
//endregion

Eclipse definisce un'annotazione javadoc @category (scorrere fino alla sezione contrassegnata come "Supporto categoria") che consente il filtraggio per categoria nella vista struttura. Non esattamente quello che vuoi. Sono sorpreso che nessuno abbia scritto un plug-in Eclipse che offre una visualizzazione come la tua schermata.

Mi è piaciuto anche quando stavo usando xcode. Per eclipse uso ctrl + o (struttura rapida) per navigare in una classe Java.

L'uso di commenti / indicatori non necessari nel codice per facilitare il lavoro potrebbe non essere una buona pratica. Ho poca idea dello sviluppo di xcode e java, ma tutto il supporto principale dell'IDE che trova i membri senza marcatori speciali come eclipse mostra i metodi ei membri che usano la vista struttura che può essere attivata usando ctrl+O, Intellij (che preferisco usare di più su Mac e aveva un community edition) ha lo stesso concetto di struttura ed è possibile accedervi rapidamente usando (ctrl + f12). Quindi il mio punto qui è non utilizzare alcun markup non necessario nel codice poiché tutti (o almeno buoni / sani) gli IDE possono farlo automaticamente.

Per quanto ne so non esiste una specifica supportata per raggruppare i membri della classe insieme. Puoi usare qualsiasi convenzione di commento che ti piace, ma è probabile che non sarà supportata da alcuno strumento.

È meglio raggruppare i membri correlati in classi separate tramite ereditarietà o aggregazione. Questo è considerato un buon stile OOP

Oltre alla risposta fornita da Andrey, per utilizzare // region // endregion, inseriamo [BigAscii letters] [1] nelle principali sezioni di codice. Quando si scorre velocemente, si distingue davvero. Uno svantaggio di questo approccio è che non posso cercarlo, quindi dovresti aggiungere un termine di ricerca appena sotto il "banner" come faccio di seguito.

Blockquote

//    _      _____          _____                  _   _
//   | |    |  __ \   /\   |  __ \      /\        | | | |
//   | |    | |  | | /  \  | |__) |    /  \  _   _| |_| |__
//   | |    | |  | |/ /\ \ |  ___/    / /\ \| | | | __| '_ \
//   | |____| |__| / ____ \| |       / ____ \ |_| | |_| | | |
//   |______|_____/_/    \_\_|      /_/    \_\__,_|\__|_| |_|
//
//   Search here with: LDAP Auth

[1]: http://patorjk.com/software/taag/#p=display&c=c%2B%2B&f=Big&t=LDAP Auth

Vorrei usare javadoc ; oppure utilizza quanto segue come un semplice "separatore" (una o tre righe):

/** RecyclerOnItemClickListener */

/** 
 * RecyclerOnItemClickListener
 */

In modo che in IDE appaia in un colore diverso dal grigio commentato non invadente.

Un IDE moderno ti consente di visualizzare il codice in molti modi diversi e persino di riorganizzarlo. Eclipse ti consente anche di visualizzare la definizione del codice su cui hai il cursore in un altro pannello.

Qualsiasi riorganizzazione automatica del codice causerà la rottura di tale markup.

Se vuoi raggruppare, considera di mettere insieme cose che appartengono alla stessa classe e cose che non appartengono insieme in classi diverse.

Se puoi raggruppare i tuoi metodi, fai un'altra classe specifica per quel concetto che vuoi catturare in una sezione. Vai avanti, la creazione di file è gratuita.

Per IntelliJ mi piace:

        public void ________________INIT__________________() {};

sembra carino nella struttura dei file!