¿Cómo marcar secciones lógicas de código en comentarios de Java?

Las clases de Java se dividen generalmente en "bloques" lógicos. ¿Existe una convención para marcar estas secciones? Idealmente, estaría respaldado por los principales IDE.

Yo personalmente uso este método:

//// Section name here ////

Sin embargo, algunos editores parecen tener problemas con esto.

Como ejemplo, en el código Objective-C puede utilizar este método:

#pragma mark -
#pragma mark Section name here

Esto dará como resultado un menú en XCode que se ve así:

Yo personalmente uso separadores de línea de 80 caracteres, como este:

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;
    }

}

Por supuesto, esto puede parecer un poco exagerado para un POJO tan pequeño, pero créanme, resultó muy útil en algunos proyectos grandes en los que tuve que navegar a través de archivos fuente grandes y encontrar rápidamente los métodos que me interesaban. También ayuda a comprender la estructura del código fuente.

En Eclipse, he creado un conjunto de plantillas personalizadas (Java -> Editor -> Plantillas en el cuadro de diálogo Preferencias de Eclipse) que generan esas barras, por ejemplo. - sepa (SEParator para Accessors) - sepp (SEParator para propiedades) - sepc (SEParator para constructores) - etc.

También modifiqué la plantilla estándar de "nueva clase" (Java -> Estilo de código -> Plantillas de código en la pantalla Preferencias de Eclipse)

Además, hay un antiguo complemento de Eclipse llamado Coffee-bytes , que mejoró la forma en que Eclipse dobla partes de código. No sé si todavía funciona, pero recuerdo que uno podría definir zonas plegables arbitrarias agregando comentarios especiales, como // [SECCIÓN] o algo así. Es posible que aún funcione en las revisiones recientes de Eclipse, así que eche un vistazo.

Para intellij / android studio hay una solución increíble.
Empiece con:
//region Description
y termine con:
//endregion

El atajo para eso está en el menú que puede abrir con Command+ Alt+ T(Mac) o Ctrl+ Alt+ T(Windows)

También puede agregar su propia línea para una separación visual adicional si la necesita. La región se puede contraer y expandir a voluntad con los botones +/- como cualquier función. También puede navegar entre regiones con Command+ Alt+ Period( Ctrl+ Alt+ Period)

Fuente .

Ejemplo:

//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 define una anotación javadoc @category (desplácese a la sección marcada "Soporte de categoría") que permite filtrar por categoría en la vista de esquema. No es exactamente lo que quieres. Me sorprende que nadie haya escrito un complemento de Eclipse que ofrezca una vista como su captura de pantalla.

Me gustó eso también cuando estaba usando xcode. Para eclipse, uso ctrl + o (esquema rápido) para navegar a través de una clase de Java.

El uso de comentarios / marcadores innecesarios en el código para ayudar a trabajar puede no ser una buena práctica. Tengo poca idea sobre el desarrollo de xcode y java, pero todos los principales IDE admiten la búsqueda de miembros sin marcadores especiales como eclipse muestran los métodos y miembros que usan la vista de esquema que se puede activar usando ctrl+O, Intellij (que prefiero usar más en mac y tenía un community edition también) tiene el mismo concepto de esquema y se puede acceder rápidamente usando (ctrl + f12). Entonces, mi punto aquí es que no use ninguna marca innecesaria en el código, ya que todos los IDE (o al menos buenos / cuerdos) pueden hacerlo automáticamente.

Hasta donde yo sé, no existe una especificación compatible para agrupar a los miembros de la clase. Puede utilizar cualquier convención de comentarios que desee, pero es probable que no sea compatible con ninguna herramienta.

Es mejor agrupar a los miembros relacionados en clases separadas mediante herencia o agregación. Esto se considera un buen estilo de programación orientada a objetos

Además de la respuesta proporcionada por Andrey, para usar // región // endregion, insertamos [letras BigAscii] [1] en las principales secciones de código. Cuando se desplaza rápido, realmente se destaca. Un inconveniente de este enfoque es que no puedo buscarlo, por lo que deberá agregar un término de búsqueda justo debajo del "banner" como hago a continuación.

Blockquote

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

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

Me gustaría utilizar javadoc ; o utilice lo siguiente como un "separador" simple (una o tres líneas):

/** RecyclerOnItemClickListener */

/** 
 * RecyclerOnItemClickListener
 */

De modo que en IDE aparece en un color diferente que no sea el discreto gris comentado.

Un IDE moderno le permite ver su código de muchas formas diferentes e incluso reorganizarlo. Eclipse incluso le permite ver la definición del código en el que tiene el cursor en otro panel.

Cualquier reorganización automática de su código hará que dicho marcado se rompa.

Si desea agrupar, considere juntar las cosas que pertenecen a la misma clase y las que no pertenecen a clases diferentes.

Si puede agrupar sus métodos, haga otra clase específicamente para ese concepto que desea capturar en una sección. Adelante, crear archivos es gratis.

Para IntelliJ me gusta:

        public void ________________INIT__________________() {};

luciendo bonito en la estructura de archivos!