Qual é a melhor prática para a utilização de “pegar” em nomes de métodos?

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

  •  06-07-2019
  •  | 
  •  

Pergunta

Tenho notado em muitos lugares em Java (C # incluído), que muitos métodos "getter" são prefixados com "get", enquanto muitos outros não são. Eu nunca notei qualquer tipo de padrão Sun parece estar seguindo. Quais são algumas orientações ou regras para a utilização de "pegar" em nomes de métodos getter?

Foi útil?

Solução

Tudo se resume a semântica. Sim, C # tem "propriedades" que lhe dão um conjunto 'método' stub get / ... mas funções (... "métodos" ...) no .NET Framework que começam com "Get" é suposto indício da desenvolvedor para o fato de que alguma operação está acontecendo com o único propósito de obter alguns resultados.

Você pode pensar que é estranho e dizer "por que não usar o tipo de retorno para clue pessoas?", Ea resposta é simples. Pense dos seguintes métodos: 

public Person CreatePerson(string firstName, string lastName) {...}

Apenas pelo nome desse método, você pode provavelmente figura que haverá atividade de banco de dados envolvidos, e, em seguida, uma "pessoa" recém-criado será devolvido.

Mas, o que sobre isso: 

public Person GetPerson(string firstName, string lastName) {...}

Apenas por que nome do método, você provavelmente pode supor que um 100% "Safe" recuperação de uma pessoa a partir de um banco de dados está sendo feito.

Você nunca chamaria os "CreatePerson" várias vezes ... mas você deve se sentir seguro para chamar de "getPerson" o tempo todo. (Não deve afetar o 'estado' do aplicativo).

Outras dicas

"get" e "set" par prefixo em Java é usado originalmente como uma convenção de feijão denotam java. Mais tarde, tornou-se apenas uma convenção encapsulamento, desde Java, não muito diferente de C # tem propriedades adequadas.

A melhor prática em Java é usar o get e prefixos conjunto de propriedades.

frameworks, bibliotecas de tags, etc irá procurar métodos com esses prefixos e usá-los como propriedades.

Então, se você tem uma classe java assim ... 

public class User{
    private String name;
    public String getName(){ return name;}
    public void setName(String name){ this.name = name; }
}

.. com struts-tags (ou qualquer outro baseado biblioteca tag OGNL), você irá acessar a propriedade nome com user.name.

O framework Spring também usa essa convenção nos arquivos de configuração XML.

Java não (ainda) propriedades de apoio. Getters e setters são uma bodge de contornar este problema. Outras línguas - incluindo C # - Propriedades de suporte e você deve usá-los em vez. Este não é apenas uma "melhor prática" coisa ou:. Serialização em C # contará com propriedades, e não getters e setters, por isso não usando propriedades pode levar a todos os tipos de problemas no futuro se você precisar serializar suas classes

A vantagem de propriedades é que eles fazem o código mais legível. Algo como 

obj.setX(10);

em Java, torna-se 

obj.X = 10;

No entanto, nos bastidores, X é um método, em vez de ser uma variável e assim podem realizar entrada sujo verificação etc.

Eu, pessoalmente, como a seguinte regra:

  • Use o prefixo get sempre que o valor é directamente modificável com um método correspondente set
  • Drop the prefixo get em situações em que o valor é algo que você não pode definir diretamente como uma propriedade (ou seja, não existe um método setXXX equivalente)

A lógica para o segundo caso é que, se o valor não é realmente uma "propriedade" configuráveis ??pelo utilizador, como tal, então não deve precisar de um par get / conjunto de métodos. Uma implicação é que se esta convenção é seguido e você vê um método getXXX, você pode supor a existência de um método setXXX também.

Exemplos:

  • String.length() - desde strings são imutáveis, o comprimento é um valor de somente leitura
  • ArrayList.size() - tamanho muda quando elementos são adicionados ou removidos, mas você não pode configurá-lo diretamente

Ele certamente costumava ser o caso que APIs muitas vezes expostos propriedades só de leitura sem o prefixo get: String.length() e até mesmo o mais recente Buffer.capacity() sendo exemplos razoáveis.

A vantagem disto é que há menos fluff envolvidos. A desvantagem é que qualquer coisa que tenta determinar as propriedades automaticamente com base nas convenções não vai descobri-los. Pessoalmente eu tendem para err no lado de incluir o prefixo.

Claro que, em C # é em grande parte irrelevante, pois há propriedades "reais" de qualquer maneira:)

Depende. Muitas vezes, é a redundância de informações, mesmo em línguas sem propriedades.

C ++, em vez de um GetAttr () / SetAttr () par, é comum fornecer duas sobrecargas de um attr () função: Atr anular (Foo f); // O setter Foo Atr (); // O getter

Em Java, é comum a prática de prefixo get / set. Eu vou ter que dizer a melhor prática é ir com o que é padrão no seu idioma. Em Java, as pessoas esperam ver entrar / prefixos definidos, assim omitindo-los pode confundir as pessoas, mesmo que eles não são estritamente necessárias.

C Objectivo 2.0 também usa propriedades, usando a mesma sintaxe de ponto.

Antes disso, é usado um esquema de nomenclatura ligeiramente diferente para getters e formadores (que, naturalmente, podem ainda ser utilizados com propriedades ou atributos para plain old). 

value = [obj attr];

[obj setAttr:value];

[obj getAttr:&value];

Isto é, get é usado de uma maneira diferente. Ela não retorna um valor, mas armazena o resultado no passado em variável.

O getter típico tem o mesmo nome que o atributo, o setter é o atributo prefixado por set (como por convenções de Java). Estas convenções são usadas pelo KVO (Key-Value Observação) do sistema, por isso deve ser respeitado.

Apenas a um curto adendo: Outra convenção é para getters de booleana campos a serem prefixados com "é" em vez de "ficar", por exemplo, bool isEnabled() { return enabled; }

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top