Nós vamos agora escrever nossos próprios métodos. Isto é como extender o vocabulário do buggle ensinando novos truques.
Por exemplo, nós vimos num exercício anterior como pedir ao buggle para
pegar o baggle na frente dele, e trazê-lo de volta. Se existem vários
baggles no tabuleiro, e se nós queremos trazê-los todos para a linha de
baixo, você tem que repetir este código várias vezes, ou incluir ele num
loop. Em qualquer caso, você deve evitar duplicar seu código para mantê-lo
agradável de ler e fácil de entender. Será melhor se o buggle puder obedecer
uma ordem vaiEPega()
assim como entende uma
[!c]avançarUmPasso()[/!][!scala|java|python]avançar()[/!]
.
A sintaxe de [!thelang] para escrever um método simples chamado
vaiEPega
é a seguinte:
[!java|c]void vaiEPega() {[/!][!python]def vaiEPega():[/!][!scala]def vaiEPega() {[/!] ações()[!java|c];[/!] ações()[!java|c];[/!] eMaisAções()[!java|c];[/!] [!java|scala|c]}[/!]
O corpo do método [!java|scala](entre chaves)[/!][!python](o bloco
indentado)[/!] será executado quando nós chamarmos o método mais tarde (ou
seja, quando nós escrevermos vaiEPega()
em algum lugar do
código). Este corpo do método pode conter tantas instruções quanto você
queira, e qualquer construção que nós queiramos (for, while, if, etc).
[!java]A palavra-chave void
significa que este método não
retorna qualquer resultado. Por exemplo, o método
estáSobreBaggle()
retorna um resultado, que é um booleano
indicando se o buggle está ou não localizado sobre um baggle. Vamos em breve
aprender a definir tais métodos também. Por agora, apenas escreva
void
neste local.[/!]
Você deve se esforçar para documentar seu código para mantê-lo legível. Quando você escreve código, fica claro o objetivo e as limitações, mas na maioria das vezes, isto é esquecido. Você rapidamente esquecerá dos detalhes de cada método específico, e vai chegar o dia em que você ficará feliz em ler a documentação. No exemplo seguinte, nós usamos o formalismo específico de [!java]javadoc[/!][!scala]scaladoc[/!][!python]pydoc[/!], um programa que extrai a documentação do código-fonte de [!thelang] e produz páginas html. A principal vantagem é que ele permite que a documentação fique junto ao código. Então, quando você mudar o código, você tem menos chances de esquecer de atualizar a documentação.
comentários em [!java|scala][!java]javadoc[/!][!scala]scaladoc[/!] começam
com a marca /**
(com dois asteriscos). Eles devem ser colocados
exatamente antes do método que documentam para a ferramenta
encontrá-los.[/!] [!python]comentários pydoc devem ser colocados no começo
do corpo do método de forma que a ferramenta possa encontrá-los. Eles devem
ser colocados entre """
, que marcam strings multilinhas em
python.[/!] A primeira linha deve ser uma breve descrição do que o método
faz enquanto que as linhas subsequentes devem fornecer qualquer detalhes
importantes sobre o método.
[!java|scala]/** * Vai, recupera o baggle na frente do buggle, e trás de volta * * Não verifica se tem paredes, então cuidado para não chamar ele * quando uma parede estiver presente. */[/!] [!java]void vaiEPega() {[/!] [!scala]def vaiEPega() {[/!] [!python]def vaiEPega(): """Vai, recupera o baggle na frente do buggle, e trás de volta. Não verifica se tem paredes, então cuidado para não chamar ele quando uma parede estiver presente."""[/!] ações()[!java];[/!] to()[!java];[/!] do()[!java];[/!] [!java|scala]}[/!]
A maioria das linguagens de programação proíbe o uso de espaços em indentificadores de métodos e variáveis (=seus nomes). Letras acentuadas são algumas vezes permitidas (como em [!thelang]), mas elas geram problemas de portabilidade entre sistemas operacionais e devem ser evitadas sempre que possível.
Entre todas as linguagens de programação, existem duas convenções para nomear variáveis e métodos. A primeira, consiste em concatenar todas as palavras com apenas a primeria letra de cada palavra em maiúscula. "vai e Pega" se torna vaiEPega(). Isto é chamado "CamelCase" por que identificadores escritos desta forma parecem graficamente com as costas de um camelo. A outra convenção, chamada "snake_case", é escrever todas as palavras em minúsculas, separadas com sublinhados (_). "vai e pega" se torna vai_e_pega().
Que convenção usar é o tópico de discussões acaloradas entre desenvolvedores, mas cada linguagem de programação tem seus próprios hábitos. Em Python, Perl e C, o snake_case é normalmente usado para métodos e variáveis. Java e Scala preferemo lowerCamelCase (só a primeira letra inicial é minúscula) para isto.
A convenção CamelCase é sempre usada no PLM por que este programa foi escrito em Java, então mantivemos o hábito quando inserimos novas linguagens. Mas o fato de os vínculos Python do PLM usarem CamelCase e não snake_case é considerado um bug que será corrigido em algum lançamento futuro.
O objetivo deste exercício é escrever um método chamado
vaiEPega()
que faça a mesma coisa que foi feita num exercício
anterior (vai para a frente até estar sobre um baggle, pega ele, vai para
trás até a posição inicial e solta o baggle).
Este exercício é um pouco diferente por que você não vai precisar escrever
todo o código executado pelo buggle. Ao invés disto, você deve apenas
escrever um método que será chamado automagicamente quando você clica em
Iniciar. Seu buggle vai chamar seu método vaiEPega()
em
cada linha, até que o baggle seja encontrado. [!python|scala]O código para
isto já está pronto no método vaiEPega()
, mas você
provavelmente não vai querer mudar isto. [/!] [!java]Você não precisa
escrever o código chamado vaiEPega()
. Ele já está lá
automaticamente, mesmo se você não possa vê-lo.[/!]
Mas para isto funcionar, você tem que na verdade escrever este método
vaiEPega()
agora.