tiene - ¿Cómo marcar secciones lógicas de código en comentarios de Java?
programas en java con comentarios (11)
Las clases de Java generalmente se dividen en "bloques" lógicos. ¿Hay una convención para marcar estas secciones? Idealmente, sería respaldado por los principales IDEs.
Yo personalmente uso este método:
//// Section name here ////
Sin embargo, algunos editores parecen tener problemas con esto.
Como ejemplo, en código Objective-C puedes usar este método:
#pragma mark -
#pragma mark Section name here
Esto dará como resultado un menú en XCode que se ve así:
Además de la respuesta proporcionada por Andrey, para usar // region // endregion, insertamos [letras de BigAscii] [1] en las principales secciones de código. Cuando se desplaza rápido, realmente se destaca. Una desventaja de este enfoque es que no puedo buscarlo, por lo que necesitaría agregar un término de búsqueda justo debajo del "banner" como lo 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
Eclipse define una anotación de @category javadoc (vaya a la sección marcada como "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 plugin de Eclipse que ofrezca una vista similar a su captura de pantalla.
Hasta donde yo sé, no existe una especificación compatible para agrupar a los miembros de la clase. Puede usar la convención de comentarios que quiera, pero es probable que no sea compatible con ninguna herramienta.
Es mejor agrupar miembros relacionados en clases separadas a través de herencia o agregación. Esto se considera un buen estilo OOP
Me gustó eso también cuando estaba usando xcode. Para eclipse utilizo ctrl + o (esquema rápido) para navegar a través de una clase Java.
Para IntelliJ me gusta:
public void ________________INIT__________________() {};
luciendo bonita en la estructura de archivos!
Para intellij / android studio hay una solución increíble.
Empezar con:
//region Description
y termina con:
//endregion
El acceso directo para eso está en el menú que puede abrir con Comando + 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 contratar y expandir a voluntad con los botones +/- como cualquier función. También puede navegar entre regiones con Comando + Alt + Período ( Ctrl + Alt + Período )
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
Si puede agrupar sus métodos, haga otra clase específicamente para ese concepto que quiera capturar en una sección. Adelante, crear archivos es gratis.
Un IDE moderno le permite ver su código de muchas maneras diferentes e incluso reorganizarlo. Eclipse incluso te permite ver la definición del código en el que tienes el cursor en otro panel.
Cualquier reorganización automática de su código hará que dicho marcado se descomponga.
Si desea agrupar, considere la posibilidad de agrupar las cosas que pertenecen en la misma clase y las que no pertenecen en clases diferentes.
Usar 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 el principal soporte de IDE para encontrar miembros sin marcadores especiales como eclipse muestra los métodos y miembros que usan la vista de esquema que puede activarse usando ctrl+O , Intellij (que prefiero usar más en mac y también tuvo una edición de comunidad) tiene el mismo concepto de esquema y se puede acceder rápidamente usando (ctrl + f12). Por lo tanto, mi punto aquí es que no utilices marcas innecesarias en el código ya que todos (o al menos buenos / cuerdos) IDE pueden hacerlo automáticamente.
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ó ser muy útil en algunos grandes proyectos en los que tuve que navegar a través de grandes archivos fuente y encontrar rápidamente los métodos que me interesaban. También ayuda a entender 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 ej. - sepa (SEParator for Accessors) - sepp (SEParator for Properties) - 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 plugin de Eclipse llamado Coffee-bytes , que mejora la forma en que Eclipse dobla porciones de código. No sé si todavía funciona, pero recuerdo que se podían definir zonas plegables arbitrarias añadiendo comentarios especiales, como // [SECCIÓN] o algo así. Todavía podría funcionar en las revisiones recientes de Eclipse, así que échale un vistazo.
Yo usaría javadoc ; o use lo siguiente como un simple "separador" (simple o 3 líneas):
/** RecyclerOnItemClickListener */
/**
* RecyclerOnItemClickListener
*/
De modo que en IDE aparece en un color diferente al discreto gris comentado.