%cabeçalho para todos os capítulos
%\input{cabecalho}

%\begin{document}

%Opções para o pacote listings
%\input{listingOptions}

\chapter{Métodos com vários parâmetros}

\begin{center}
\shabox{
  \begin{Bitemize}
    \item[]\textbf{Quais novidades veremos nesta aula?}
    \item Métodos que devolvem nada (\texttt{void});
    \item Métodos com vários parâmetros;
    \item Atributos.
    \end{Bitemize}
} % \shabox
\end{center}
\bigskip

\section{Métodos com vários parâmetros}

Na última aula nós já vimos um método que recebia vários parâmetros.
Apesar de não estarmos apresentando nenhuma novidade conceitual vamos
reforçar a possibilidade da passagem de mais de um parâmetro.

Assim como na passagem de apenas um parâmetro, é necessário que o valor
passado seja do mesmo tipo do que o valor que o método está esperando.
Por exemplo, se um objeto (ator) tem um método (entende uma mensagem)
que tem como parâmetro um número inteiro não podemos enviar a este
objeto um número \texttt{double}. Apesar de ser intuitivo, também vale
ressaltar que a ordem dos parâmetros é importante, na chamada de um
método devemos respeitar a mesma ordem que está na sua definição.

Vamos começar com o cálculo da área de uma circunferência, onde é
necessário apenas um parâmetro, o raio:

\begin{lstlisting}
class Círculo1
{
  double calculaÁrea(double raio)
  {
    return 3.1415 * raio * raio;
  }
}
\end{lstlisting}

\begin{center}
\begin{boxedminipage}[t]{14cm}
  \textbf{Nota Linguística:} Em Java, o nome de variáveis, classes e métodos
  pode conter caracteres acentuados. Muitos programadores evitam o uso de
  acentuação mesmo ao usar nomes em português. Este costume advém de outras
  linguagens mais antigas, como C, que não permitem o uso de caracteres
  acentuados. Você pode usar caracteres acentuados se quiser mas lembre-se que
  se você tiver uma variável chamada \texttt{área}, ela será diferente de
  outra chamada \texttt{area} (sem acento); ou seja, se você decidir usar
  acentos, deverá usá-los consistentemente sempre.
\end{boxedminipage}
\end{center}
\bigskip

Podemos sofisticar o exemplo calculando também o perímetro, com o
seguinte método:

\begin{lstlisting}
double calculaPerímetro(double raio)
{
  return 3.1415 * 2.0 * raio;
}
\end{lstlisting}

O seguinte trecho de código calcula e imprime a área e perímetro de uma
circunferência de raio 3.0:

\begin{lstlisting}
Círculo1 c = new Círculo1();

System.out.println(c.calculaÁrea(3.0));
System.out.println(c.calculaPerímetro(3.0));
\end{lstlisting}

Vejamos agora uma classe \texttt{Retângulo} que define métodos para o cálculo
do perímetro e da área de um retângulo. Neste caso são necessários dois
parâmetros.

\begin{lstlisting}
class Retângulo1
{
  int calculaÁrea(int lado1, int lado2)
  {
    return lado1 * lado2;
  }
  int calculaPerímetro(int lado1, int lado2)
  {
    return 2 * (lado1 + lado2);
  }
}
\end{lstlisting}

As chamadas para os métodos podem ser da seguinte forma:

\begin{lstlisting}
Retângulo1 r = new Retângulo1();

System.out.println(r.calculaÁrea(2, 3));
System.out.println(r.calculaPerímetro(2, 3));
\end{lstlisting}

Mas, assim como no exemplo do teatrinho dos objetos onde os jogadores
tinham como característica o time e o número da camisa (atributos),
também podemos ter algo semelhante para o caso dos retângulos. Podemos
fazer com que os dados sobre os lados sejam características dos objetos.
Isto é feito da seguinte forma:

\begin{lstlisting}
class Retângulo2
{
  int lado1;
  int lado2;

  int calculaÁrea()
  {
    return lado1 * lado2;
  }
  int calculaPerímetro()
  {
    return 2 * (lado1 + lado2);
  }
}
\end{lstlisting}

Entretando fica faltando algum método para carregar os valores dos
lados nas variáveis \texttt{lado1} e \texttt{lado2}.

\begin{lstlisting}
void carregaLados(int l1, int l2) // este método não devolve nenhum valor
{
  lado1 = l1;
  lado2 = l2;
}
\end{lstlisting}

\begin{center}
\begin{boxedminipage}[t]{14cm}
  \textbf{Nota Linguística:} \texttt{void} em inglês significa o vazio, nada,
  ou nulidade.
\end{boxedminipage}
\end{center}
\bigskip

O funcionamento de um objeto da classe \texttt{Retângulo} pode ser verificado
com o código abaixo:

\begin{lstlisting}
Retângulo2 r = new Retângulo2();

r.carregaLados(3, 5);
System.out.println(r.calculaÁrea());
System.out.println(r.calculaPerímetro());
\end{lstlisting}

Para não perdermos o hábito, também veremos como testar esta classe.  Neste
caso, temos duas opções, criar diversos objetos do tipo \texttt{Retângulo}, ou
carregar diversos lados. Veja abaixo as duas opções:

\begin{lstlisting}
class TestaRetângulo
{
  void testePontual(int l1, int l2)
  {
    Retângulo2 r = new Retângulo2();

    r.carregaLados(l1, l2);
    if (r.calculaÁrea() != l1 * l2)
      System.out.println("Não funciona área para lados "
                         + l1 + " e " + l2);
    if (r.calculaPerímetro() != 2 * (l1 + l2))
      System.out.println("Não funciona perímetro para lados "
                         + l1 + " e " + l2);
  }

  void testaTudo ()
  {
    testePontual(10, 20);
    testePontual(1, 2);
    testePontual(3, 3);
  }
}
\end{lstlisting}

Da mesma forma que os lados foram atributos para a classe \texttt{Retângulo2},
podemos fazer o mesmo para a classe \texttt{Círculo1}.

\begin{lstlisting}
class Círculo2
{
  double raio;

  void carregaRaio( double r)
  {
    raio = r;
  }
  double calculaÁrea()
  {
    return 3.1415 * raio * raio;
  }
  double calculoPerímetro()
  {
    return 3.1415 * 2.0 * raio;
  }
}
\end{lstlisting}

Assim como vimos anteriormente podemos também utilizar objetos de
uma classe sem conhecer a sua implementação. Por exemplo suponha que temos
acesso a uma classe \texttt{Cálculo} que possui o seguinte método:

\begin{lstlisting}
int calculaPotência(int x, int n);
\end{lstlisting}

Para calcular a potência poderiamos ter o seguinte trecho de código:

\begin{lstlisting}
Cálculo c = new Cálculo();

System.out.println("2 elevado a 5 é igual a: " + c.calculaPotência(2, 5));
\end{lstlisting}

\section{Exercícios}

\subsection*{Métodos com vários parâmetros}

\begin{enumerate}
  
\item Calcular a média aritmética de 4 notas e dizer se o dono das notas foi
  aprovado, está de recuperação ou foi reprovado. Por exemplo,

\begin{itemize}
\item Entrada:
\begin{verbatim}
8.7, 7.2, 9.3, 7.4
5.2, 3.4, 6.5, 2.1
3.4, 5.1, 1.1, 2.0
\end{verbatim}
\end{itemize}

\begin{itemize}
\item Saída:
\begin{verbatim}
Média: 8.15 -> aprovado.
Média: 4.3 -> recuperação.
Média: 2.9 -> reprovado.
\end{verbatim}
\end{itemize}

Para isso, crie uma classe \texttt{Aluno} com métodos que carreguem as 4 notas
em variáveis \texttt{p1}, \texttt{p2}, \texttt{p3}, \texttt{p4} e um método
responsável por calcular a média aritmética das notas e dar o ``veredito''.

\end{enumerate}

\subsection*{Atributos}

\begin{enumerate}
  
\item Construa a classe \texttt{Inteiro} que representa um número inteiro.
Essa classe deve ter os seguintes atributos e métodos:

%\begin{minipagec}{10cm}

\smallskip
{\singlespacing
\doublebox{
\begin{minipage}{14cm}
\begin{Bitemize}
\item[] \textbf{Classe \texttt{Inteiro}} \\ ~ \\
\begin{Bitemize}
  \item Atributos: \\ ~ \\
  \begin{Bitemize}
    \item \texttt{int valor} \\
        Valor do inteiro representado.
  \end{Bitemize} \\
  \item Métodos para interação com o usuário da classe: \\ ~ \\
  \begin{Bitemize}
    \item \texttt{void carregaValor(int v)} \\
                  Muda o valor representado por este objeto. O novo valor deve ser \texttt{v}.
    \item \texttt{int devolveValor()} \\
                  Devolve o valor representado por este objeto.
    \item \texttt{int devolveValorAbsoluto()} \\
                  Devolve o valor absoluto do valor representado por este objeto.
    \item \texttt{void imprime()} \\
                  Imprime algo que representa este objeto. Sugestão: imprima o valor.
  \end{Bitemize} \\
\end{Bitemize} \\
\end{Bitemize} \\
\end{minipage}
}
}
\medskip

Exemplo de uso no DrJava:

\begin{verbatim}
  > Inteiro i = new Inteiro();
  > i.carregaValor(14);
  > i.devolveValor()
  14
  > i.carregaValor(-473158);
  > i.devolveValor()
  -473158
  > i.devolveValorAbsoluto()
  473158
  > i.imprime();
  Valor: -473158.
\end{verbatim}

\item Acrescente à classe \texttt{Inteiro} algumas operações matemáticas,
  implementando os seguintes métodos:

\smallskip
{\singlespacing
\doublebox{
\begin{minipage}{14cm}
\begin{Bitemize}
\item[] \textbf{Classe \texttt{Inteiro}}  \\ ~ \\
\begin{Bitemize}
  \item Mais métodos para interação com o usuário da classe:  \\ ~ \\
  \begin{Bitemize}
\item \texttt{int soma(int v)} \\
      Soma v ao valor deste objeto (valor + v). Este objeto passa representar o novo \\
      valor, que também deve ser devolvido pelo método.
\item \texttt{int subtrai(int v)} \\
      Subtrai v do valor deste objeto (valor - v). Este objeto passa representar o novo \\
      valor, que também deve ser devolvido pelo método.
\item \texttt{int multiplicaPor(int v)} \\
      Multiplica o valor deste objeto por v (valor * v). Este objeto passa representar o\\
      novo valor, que também deve ser devolvido pelo método.
\item \texttt{int dividePor(int divisor)} \\
      Verifica se divisor é diferente de zero. Se não, imprime uma mensagem de erro e \\
      não faz nada (devolve o valor inalterado). Se for, divide o valor deste objeto por\\
      v (valor / divisor, divisão inteira). Este objeto passa representar o novo valor, \\
      que também deve ser devolvido pelo método.
  \end{Bitemize}
\end{Bitemize}
\end{Bitemize}
\end{minipage}
}
}
\medskip

Exemplo de uso no DrJava:

\begin{verbatim}
> Inteiro i = new Inteiro();
> i.carregaValor(15);
> i.subtrai(20)
-5
> i.devolveValor()
-5
\end{verbatim}

Se quiser, você também pode fazer versões desses métodos que não alteram o
valor representado, apenas devolvem o valor da conta.

\end{enumerate}

%\end{document}
