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

%\begin{document}

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

\chapter{\texttt{if else} encaixados }

\begin{center}
\shabox{
  \begin{Bitemize}
    \item[]\textbf{Quais novidades veremos nesta aula?}
    \item novidade: \texttt{if else} encaixados
    \item exercício para reforçar o que aprendemos até agora.
    \end{Bitemize}
} % \shabox
\end{center}
\bigskip

\section{\texttt{if else} encaixados}

Vamos iniciar programando uma classe para representar um triângulo
retângulo. Ela contém um método que, dados os comprimentos dos lados
do triângulo, verifica se o mesmo é retângulo ou não.

\begin{lstlisting}
class TrianguloRetangulo
{
  void verificaLados (int a, int b, int c)
  {
    if (a * b * c != 0) // nenhum lado pode ser nulo
    {
      if (a*a == b*b + c*c)
        System.out.println("Triângulo retângulo.");
      if (b*b == a*a + c*c)
        System.out.println("Triângulo retângulo.");
      if (c*c == a*a + b*b)
        System.out.println("Triângulo retângulo.");
    }
  }
}
\end{lstlisting}
O método acima pode ser chamado da seguinte forma:

\begin{lstlisting}
TrianguloRetangulo1 r = new TrianguloRetangulo1 ();
r.verificaLados (1, 1, 1);
r.verificaLados (3, 4, 5);
\end{lstlisting}

Limitações:
\begin{enumerate}
\item mesmo que um \texttt{if} seja verdadeiro, ele executa os outros \texttt{if}s.
Em particular, se tivéssemos um triângulo retângulo para o qual vários
desses \texttt{if}s fossem verdadeiros, ele imprimiria esta mensagem
várias vezes (será que isso é possível neste caso específico???);
\item este método só imprime uma mensagem se os dados correspondem às medidas
de um triângulo retângulo, se não é um triângulo retângulo, ele não
imprime nada. Através do uso do \texttt{else} podemos imprimir mensagens
afirmativas e negativas:
\end{enumerate}

\begin{lstlisting}
class TrianguloRetangulo2
{
  void verificaLados (int a, int b, int c)
  {
    if (a * b * c != 0) // nenhum lado pode ser nulo
    {
      if (a*a == b*b + c*c)
        System.out.println ("Triângulo retângulo.");
      else if (b*b == a*a + c*c)
        System.out.println ("Triângulo retângulo.");
      else if (c*c == a*a + b*b)
        System.out.println ("Triângulo retângulo.");
      else
        System.out.println ("Não é triângulo retângulo.");
    }
    else System.out.println ("Não é triângulo pois possui lado de comprimento nulo.");
  }
}
\end{lstlisting}

Caso sejam necessários outros métodos, como um para o cálculo de perímetro,
é interessante colocar os lados como atributos da classe.

\begin{lstlisting}
class TrianguloRetangulo3
{
  int a, b, c;
  void carregaLados (int l1, int l2, int l3)
  {
    a = l1;
    b = l2;
    c = l3;
  }
  int calculaPerimetro ()
  {
    return a + b + c;
  }
  void verificaLados ()
  {
    if (a * b * c != 0) // nenhum lado pode ser nulo
    {
      if (a*a == b*b + c*c)
        System.out.println ("Triângulo retângulo.");

      else if (b*b == a*a + c*c)
        System.out.println ("Triângulo retângulo.");

      else if (c*c == a*a + b*b)
        System.out.println ("Triângulo retângulo.");

      else
        System.out.println ("Não é triângulo retângulo.");
    }
    else
      System.out.println ("Não é triângulo pois possui lado de comprimento nulo.");

  }
}
\end{lstlisting}

\section{Exercícios}

\begin{enumerate}

\item Você foi contratado por uma agência de viagens para escrever uma classe
  em Java para calcular a conversão de reais para dólar de acordo com
  a taxa de compra e a taxa de venda. Para isso, escreva uma classe
  \texttt{ConversorMonetário} que inclua os seguintes métodos:

\begin{enumerate}
\item \texttt{defineTaxaCompra()} e \texttt{defineTaxaVenda()}.
\item \texttt{imprimeTaxas()} que imprime o valor das 2 taxas de
conversão.
\item \texttt{vendeDólar()} que recebe uma quantia em dólares e devolve
o valor correspondente em reais.
\item \texttt{compraDólar()} que recebe uma quantia em dólares e
devolve o valor correspondente em reais.
\end{enumerate}

\item Escreva uma classe \texttt{Baskara} que possui 3 atributos do tipo
  double correspondentes aos coeficientes $a$, $b$ e $c$ de uma equação do segundo
  grau. Escreva um método para carregar valores nestes atributos e, em
  seguida, escreva os 4 métodos seguintes:

\begin{enumerate}
\item \texttt{delta()} deve calcular o \(\delta\) da fórmula de Baskara.
\item \texttt{númeroDeRaízesReais()} deve devolver um inteiro indicando quantas raízes reais a equação possui.
\item \texttt{raízesReais()} deve imprimir as raízes reais.
\item \texttt{raízesImaginárias()} deve imprimir as raízes imaginárias.
\end{enumerate}

Para calcular a raiz quadrada, você pode utilizar o método
\texttt{java.lang.Math.sqrt(double \textbf{x})}, que recebe um double como
parâmetro e devolve outro double. Você pode supor que o primeiro coeficiente,
$a$, é diferente de 0.

\item \textbf{[Desafio!]} \emph{São apresentadas a você doze esferas de
    aparência idêntica. Sabe-se que apenas uma delas é levemente diferente das
    demais em massa, mas não se sabe qual, e nem se a massa é maior ou menor.
    Sua missão é identificar essa esfera diferente, e também dizer se ela é
    mais ou menos pesada. Para isso você tem apenas uma balança de prato (que
    só permite determinar igualdades/desigualdades). Ah, sim, pequeno detalhe:
    o desafio é completar a missão em não mais que três pesagens.}
  
  Escreva um programa que resolve esse desafio. O seu programa deve dar uma
  resposta correta sempre e também informar as três ou menos pesagens que
  permitiram concluir a resposta.Como esse problema é um tanto complicado,
  recomendamos que você implemente o modelo descrito a seguir.

\smallskip
{\singlespacing
\doublebox{
\begin{minipage}{14cm}
\begin{Bitemize}
\item[] \textbf{Classe \texttt{DesafioDasEsferas}} \\~\\
\begin{Bitemize}
  \item Atributos:  \\~\\
  \begin{Bitemize}
    \item \texttt{int esferaDiferente} \\
          Identificador da esfera com peso diferente.
    \item \texttt{boolean maisPesada} \\
          Diz se a esfera diferente é ou não mais pesada que as demais (isto é, true \\
          para mais pesada e false para mais leve).
    \item \texttt{int numPesagens} \\
          Representa o número de pesagens realizadas.
  \end{Bitemize} \\
  \item Métodos para interação com o usuário:  \\~\\
  \begin{Bitemize}
    \item \texttt{void defineEsferaDiferente(int esfera, boolean pesada)} \\
          \parbox{12.5cm}{Determina qual é a esfera diferente (parâmetro esfera), e se ela é mais pesada ou não (parâmetro pesada). Além disso, reinicia as pesagens, isto é, o número de pesagens realizadas volta a ser zero.}\\
    \item \texttt{void resolveDesafioDasDozeEsferas()} \\
          \parbox{12.5cm}{Resolve o Desafio das Doze das Esferas. Este método deve imprimir as 3 (ou menos) pesagens feitas, e no final a resposta correta. Este método deve se utilizar dos métodos para uso interno descritos abaixo. Dica: na implementação deste método você também usará uma quantidade grande de ifs e elses encaixados.} \\
  \end{Bitemize} \\
  \item Métodos para uso interno da classe:  \\~\\
  \begin{Bitemize}
    \item \texttt{int pesa1x1(int e1, int d1)}
    \item \texttt{int pesa2x2(int e1, int e2, int d1, int d2)}
    \item \texttt{int pesa3x3(int e1, int e2, int e3, int d1, int d2, int d3)}
    \item \texttt{int pesa4x4(int e1, int e2, int e3, int e4, int d1, int d2,} \\
          \texttt{int d3, int d4)}
    \item \texttt{int pesa5x5(int e1, int e2, int e3, int e4, int e5, int d1,} \\
          \texttt{int d2, int d3, int d4, int d5)}
    \item \texttt{int pesa6x6(int e1, int e2, int e3, int e4, int e5, int e6,} \\
          \texttt{int d1, int d2, int d3, int d4, int d5, int d6)} \\ ~ \\

\parbox{12.5cm}{
Os métodos acima (no formato pesa\#x\#) funcionam de forma semelhante. Eles representam as possíveis pesagens, e devolvem o resultado. Os parâmetros representam as esferas que são pesadas, os começados por e (ou seja, e1, e2, ...) representam esferas que vão para o prato esquerdo e os começados por d (d1, d2, ...) são as do prato direito. Lembrando, cada esfera é representada por um inteiro entre 1 e 12. Então, por exemplo, para comparar as esferas 1, 7 e 3 com as esferas 4, 5 e 6, basta chamar pesa3x3(1,7,3,4,5,6). Os métodos devem devolver -1 se a balança pender para o lado esquerdo, 0 se os pesos forem iguais ou 1 se a balança pender para o lado direito. Esses métodos também devem incrementar o número de pesagens realizadas.}
  \end{Bitemize}
\end{Bitemize}
\end{Bitemize}
\end{minipage}
}
}
\medskip

Cada esfera deve ser representada por um inteiro entre 1 e 12. Para representarmos a esfera diferente, usaremos, além do identificador inteiro, uma variável booleana que receberá o valor true se a esfera for mais pesada ou o valor false se a esfera for mais leve.

Importante: note que para que o problema tenha sentido, o método resolveDesafioDasDozeEsferas não deve de modo algum acessar os atributos esferaDiferente e maisPesada para inferir a resposta. Quem dá pistas para este método sobre o valor desses atributos são os métodos pesa\#x\#.

Lembre-se de que você também pode implementar métodos adicionais, se achar necessário ou mais elegante. Ou ainda, se você já se sente seguro(a), você pode implementar a(s) sua(s) própria(s) classe(s).

Exemplo de uso no DrJava:

\begin{verbatim}
> DesafioDasEsferas dde = new DesafioDasEsferas();
> dde.defineEsferaDiferente(4, false);
Início do desafio: esfera 4 mais leve.
> dde.resolveDesafioDasDozeEsferas();
Pesagem 1: 1 2 3 4 5 x 6 7 8 9 10.
Resultado: (1) lado direito mais pesado.
Pesagem 2: 1 2 x 3 4.
Resultado: (-1) lado esquerdo mais pesado.
Pesagem 3: 1 x 2.
Resultado: (0) balança equilibrada.
Resposta: esfera 3 mais leve.
[Resposta errada!]
\end{verbatim}

Note que a resposta está errada! (Além disso, as pesagens não permitem dar a resposta certa.)


\end{enumerate}

%\end{document}