Como marcar seções lógicas de código em comentários Java?

As classes Java geralmente são divididas em "blocos" lógicos. Existe uma convenção para marcar essas seções? Idealmente, seria apoiado pelos principais IDEs.

Eu pessoalmente uso este método:

//// Section name here ////

No entanto, alguns editores parecem ter problemas com isso.

Por exemplo, no código Objective-C, você pode usar este método:

#pragma mark -
#pragma mark Section name here

Isso resultará em um menu no XCode semelhante a este:

Eu pessoalmente uso separadores de linha de 80 caracteres, assim:

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

}

Claro, isso pode parecer um pouco exagerado para um POJO tão pequeno, mas acredite em mim, ele provou ser muito útil em alguns projetos enormes em que tive que navegar por grandes arquivos de origem e encontrar rapidamente os métodos nos quais estava interessado. Também ajuda a entender a estrutura do código-fonte.

No Eclipse, criei um conjunto de modelos personalizados (Java -> Editor -> Modelos na caixa de diálogo Preferências do Eclipse) que geram essas barras, por exemplo. - sepa (SEParator para Acessores) - sepp (SEParator para Propriedades) - sepc (SEParator para Construtores) - etc.

Eu também modifiquei o modelo padrão de "nova classe" (Java -> Estilo de Código -> Modelos de Código na tela Preferências do Eclipse)

Além disso, há um plug - in antigo do Eclipse chamado Coffee-bytes , que aprimorou a maneira como o Eclipse dobra partes do código. Não sei se ainda funciona, mas lembrei que é possível definir zonas dobráveis ​​arbitrárias adicionando comentários especiais, como // [SEÇÃO] ou algo assim. Ele ainda pode funcionar em revisões recentes do Eclipse, então dê uma olhada.

Para o intellij / android studio, há uma solução incrível.
Comece com:
//region Description
e termine com:
//endregion

O atalho para isso está no menu que você pode abrir com Command+ Alt+ T(Mac) ou Ctrl+ Alt+ T(Windows)

Você também pode adicionar sua própria linha para separação visual adicional, se necessário. A região pode ser contraída e expandida à vontade com os botões +/- como qualquer função. Você também pode navegar entre as regiões com Command+ Alt+ Period( Ctrl+ Alt+ Period)

Fonte .

Exemplo:

//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

O Eclipse define uma anotação @category javadoc (role para a seção marcada como "Suporte de categoria") que permite a filtragem por categoria na visualização da estrutura de tópicos. Não é exatamente o que você quer. Estou surpreso que ninguém tenha escrito um plugin do Eclipse que oferece uma visão como a sua captura de tela.

Eu gostava disso também quando estava usando o xcode. Para o eclipse, uso ctrl + o (esboço rápido) para navegar por uma classe Java.

Usar comentários / marcadores desnecessários no código para ajudar a trabalhar pode não ser uma boa prática. Não tenho nenhuma ideia sobre o desenvolvimento xcode e java, mas todo o suporte do IDE principal para encontrar os membros sem quaisquer marcadores especiais como eclipse mostra os métodos e membros usando a visualização de estrutura de tópicos que pode ser acionada usando ctrl+OIntellij (que eu prefiro usar mais no mac e tinha um edição da comunidade também) tem o mesmo conceito de contorno e pode ser acessado rapidamente usando (ctrl + f12). Portanto, meu ponto aqui é não usar nenhuma marcação desnecessária no código, pois todos (ou pelo menos bons / sãos) IDE podem fazer isso automaticamente.

Pelo que eu sei, não existe uma especificação com suporte para agrupar membros de classe. Você pode usar qualquer convenção de comentário que desejar, mas é provável que não seja suportada por nenhuma ferramenta.

É melhor agrupar membros relacionados em classes separadas por herança ou agregação. Este é considerado um bom estilo OOP

Além da resposta de Andrey fornecida, para usar // região // endregion, inserimos [letras BigAscii] [1] nas seções principais do código. Ao rolar rápido, ele realmente se destaca. Uma desvantagem dessa abordagem é que não posso pesquisá-lo, então você precisa adicionar um termo de pesquisa logo abaixo do "banner", como faço abaixo.

Bloco de citação

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

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

Eu usaria javadoc ; ou use o seguinte como um "separador" simples (uma ou 3 linhas):

/** RecyclerOnItemClickListener */

/** 
 * RecyclerOnItemClickListener
 */

Para que no IDE ele apareça em uma cor diferente do cinza discreto comentado.

Um IDE moderno permite que você visualize seu código de muitas maneiras diferentes e até mesmo o reorganize. O Eclipse ainda permite que você visualize a definição do código sobre o qual você tem o cursor em outro painel.

Qualquer reorganização automática de seu código fará com que essa marcação seja interrompida.

Se você quiser agrupar, considere colocar coisas que pertencem à mesma classe e coisas que não pertencem a classes diferentes.

Se você pode agrupar seus métodos, faça outra aula especificamente para aquele conceito que você deseja capturar em uma seção. Vá em frente, a criação de arquivos é gratuita.

Para IntelliJ eu gosto de:

        public void ________________INIT__________________() {};

bonito na estrutura do arquivo!