E se quisermos dizer “Olá” várias vezes sem cansar os dedos? Temos que
definir um método!

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):010:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span>
<span class="gp">irb(main):011:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Olá Mundo!"</span>
<span class="gp">irb(main):012:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="ss">:h</span></code></pre></figure>

O código `def h` começa a definição do método. Diz ao Ruby que estamos
definindo um método, cujo nome é `h`. A linha seguinte é o corpo do
método, a mesma linha que vimos antes: `puts "Olá Mundo"`. Finalmente, a
última linha `end` diz ao Ruby que terminámos a definição do método.
A reposta do Ruby `=> :h` nos diz que ele sabe que estamos definindo um
método. Essa resposta poderia ser `=> nil` no Ruby 2.0 e versões anteriores.
Mas isso não é importante agora, vamos seguir em frente.

## As Breves e Repetitivas Vidas de um Método

Agora vamos tentar rodar o método algumas vezes:

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):013:0&gt;</span><span class="w"> </span><span class="n">h</span>
<span class="go">Olá Mundo!
</span><span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):014:0&gt;</span><span class="w"> </span><span class="n">h</span><span class="p">()</span>
<span class="go">Olá Mundo!
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Bem, isso foi fácil. Chamar um método em Ruby é tão fácil como mencionar
o seu nome ao Ruby. Se o método não tiver parâmetros isso é tudo de que
precisamos. Podemos também colocar os parênteses vazios se desejarmos,
porém eles não são necessários.

E se o que queremos é dizer olá a uma pessoa só, e não ao mundo inteiro?
Para isso basta redifinir `h` para que aceite um nome como parâmetro.

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):015:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span><span class="p">(</span><span class="n">nome</span><span class="p">)</span>
<span class="gp">irb(main):016:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Olá </span><span class="si">#{</span><span class="n">nome</span><span class="si">}</span><span class="s2">!"</span>
<span class="gp">irb(main):017:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="ss">:h</span>
<span class="gp">irb(main):018:0&gt;</span><span class="w"> </span><span class="n">h</span><span class="p">(</span><span class="s2">"Matz"</span><span class="p">)</span>
<span class="go">Ola Matz!
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Parece funcionar… mas vamos parar um minuto para ver o que se passa
aqui.

## Reservando Espaços numa String

O que significa a expressão `#{name}`? É a forma de inserir alguma coisa
numa string. Aquilo que se encontra entre chaves transforma-se numa
string (se já não o for) e é substituído naquele ponto da string.
Podemos também usar isto para ter a certeza de que o nome de alguém se
apresenta em letra maiúscula:

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):019:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span><span class="p">(</span><span class="n">nome</span> <span class="o">=</span> <span class="s2">"Mundo"</span><span class="p">)</span>
<span class="gp">irb(main):020:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Olá </span><span class="si">#{</span><span class="n">nome</span><span class="p">.</span><span class="nf">capitalize</span><span class="si">}</span><span class="s2">!"</span>
<span class="gp">irb(main):021:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="ss">:h</span>
<span class="gp">irb(main):022:0&gt;</span><span class="w"> </span><span class="n">h</span> <span class="s2">"chris"</span>
<span class="go">Olá Chris!
</span><span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):023:0&gt;</span><span class="w"> </span><span class="n">h</span>
<span class="go">Olá Mundo!
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Podemos encontrar aqui um truque ou dois. Um deles é que estamos
chamando novamente o método sem recorrer aos parênteses. Se aquilo que
estamos fazendo for óbvio então os parênteses são opcionais. O outro
truque é o parâmetro `Mundo` usado por omissão. O que isto quer dizer é
que “Se o nome não for fornecido, então usamos o nome padrão
`"Mundo"`.

## Evoluindo para um Anfitrião

E se quisermos criar um verdadeiro anfitrião, um que se lembre do
nosso nome, nos dê as boas vindas e nos trate com o devido respeito?
Podemos usar um objeto para isso. Então vamos criar a classe “Anfitrião”.

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):024:0&gt;</span><span class="w"> </span><span class="k">class</span> <span class="nc">Anfitriao</span>
<span class="gp">irb(main):025:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">nome</span> <span class="o">=</span> <span class="s2">"Mundo"</span><span class="p">)</span>
<span class="gp">irb(main):026:2&gt;</span><span class="w">     </span><span class="vi">@nome</span> <span class="o">=</span> <span class="n">nome</span>
<span class="gp">irb(main):027:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):028:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">diz_ola</span>
<span class="gp">irb(main):029:2&gt;</span><span class="w">     </span><span class="nb">puts</span> <span class="s2">"Olá </span><span class="si">#{</span><span class="vi">@nome</span><span class="si">}</span><span class="s2">!"</span>
<span class="gp">irb(main):030:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):031:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">diz_adeus</span>
<span class="gp">irb(main):032:2&gt;</span><span class="w">     </span><span class="nb">puts</span> <span class="s2">"Adeus </span><span class="si">#{</span><span class="vi">@nome</span><span class="si">}</span><span class="s2">, volte sempre."</span>
<span class="gp">irb(main):033:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):034:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

A nova palavra-chave aqui é `class`. Ela define uma nova classe chamada
Anfitrião e alguns métodos para essa classe. E o `@nome` ? É
uma variável de instância e está disponível para todos os métodos da
classe. Como podemos ver, ela é utilizada por `diz_ola` e `diz_adeus`.

Então como é que fazemos a classe Anfitrião funcionar? [Criamos um
objeto.](../3/)
